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 <jh@suse.cz>.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28 #include "bfd_stdint.h"
  29
  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       /* When building a static executable, use .iplt, .igot.plt and
1797          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
1798       if (htab->splt != 0)
1799         {
1800           plt = htab->splt;
1801           gotplt = htab->sgotplt;
1802           relplt = htab->srelplt;
1803
1804           /* If this is the first .plt entry, make room for the special
1805              first entry.  */
1806           if (plt->size == 0)
1807             plt->size += PLT_ENTRY_SIZE;
1808         }
1809       else
1810         {
1811           plt = htab->iplt;
1812           gotplt = htab->igotplt;
1813           relplt = htab->irelplt;
1814         }
1815
1816       /* Don't update value of STT_GNU_IFUNC symbol to PLT.  We need
1817          the original value for R_X86_64_IRELATIVE.  */
1818       h->plt.offset = plt->size;
1819
1820       /* Make room for this entry in the .plt/.iplt section.  */
1821       plt->size += PLT_ENTRY_SIZE;
1822
1823       /* We also need to make an entry in the .got.plt/.got.iplt
1824          section, which will be placed in the .got section by the
1825          linker script.  */
1826       gotplt->size += GOT_ENTRY_SIZE;
1827
1828       /* We also need to make an entry in the .rela.plt/.rela.iplt
1829          section.  */
1830       relplt->size += sizeof (Elf64_External_Rela);
1831       relplt->reloc_count++;
1832
1833       /* No need for dynamic relocation for local STT_GNU_IFUNC symbol.
1834          Discard space for relocations against it.  */
1835       if (h->dynindx == -1 || h->forced_local)
1836         eh->dyn_relocs = NULL;
1837
1838       /* STT_GNU_IFUNC symbol uses .got.plt, not .got.  But for
1839          shared library, we must go through GOT and we can't
1840          use R_X86_64_IRELATIVE unless it is forced local.   */
1841       if (info->executable
1842           || info->symbolic
1843           || h->forced_local)
1844         {
1845           if (h->pointer_equality_needed
1846               && htab->sgot != NULL)
1847             {
1848               /* We can't use .got.plt, which contains the real
1849                  function addres, since we need pointer equality.
1850                  We will load the GOT entry with the PLT entry
1851                  in elf64_x86_64_finish_dynamic_symbol and don't
1852                  need GOT relocation.  */
1853               h->got.offset = htab->sgot->size;
1854               htab->sgot->size += GOT_ENTRY_SIZE;
1855               eh->tlsdesc_got = (bfd_vma) -1;
1856               goto skip_relgot;
1857             }
1858           else
1859             h->got.refcount = 0;
1860         }
1861     }
1862   else if (htab->elf.dynamic_sections_created
1863            && h->plt.refcount > 0)
1864     {
1865       /* Make sure this symbol is output as a dynamic symbol.
1866          Undefined weak syms won't yet be marked as dynamic.  */
1867       if (h->dynindx == -1
1868           && !h->forced_local)
1869         {
1870           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1871             return FALSE;
1872         }
1873
1874       if (info->shared
1875           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1876         {
1877           asection *s = htab->splt;
1878
1879           /* If this is the first .plt entry, make room for the special
1880              first entry.  */
1881           if (s->size == 0)
1882             s->size += PLT_ENTRY_SIZE;
1883
1884           h->plt.offset = s->size;
1885
1886           /* If this symbol is not defined in a regular file, and we are
1887              not generating a shared library, then set the symbol to this
1888              location in the .plt.  This is required to make function
1889              pointers compare as equal between the normal executable and
1890              the shared library.  */
1891           if (! info->shared
1892               && !h->def_regular)
1893             {
1894               h->root.u.def.section = s;
1895               h->root.u.def.value = h->plt.offset;
1896             }
1897
1898           /* Make room for this entry.  */
1899           s->size += PLT_ENTRY_SIZE;
1900
1901           /* We also need to make an entry in the .got.plt section, which
1902              will be placed in the .got section by the linker script.  */
1903           htab->sgotplt->size += GOT_ENTRY_SIZE;
1904
1905           /* We also need to make an entry in the .rela.plt section.  */
1906           htab->srelplt->size += sizeof (Elf64_External_Rela);
1907           htab->srelplt->reloc_count++;
1908         }
1909       else
1910         {
1911           h->plt.offset = (bfd_vma) -1;
1912           h->needs_plt = 0;
1913         }
1914     }
1915   else
1916     {
1917       h->plt.offset = (bfd_vma) -1;
1918       h->needs_plt = 0;
1919     }
1920
1921   eh->tlsdesc_got = (bfd_vma) -1;
1922
1923   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1924      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
1925   if (h->got.refcount > 0
1926       && !info->shared
1927       && h->dynindx == -1
1928       && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
1929     {
1930       h->got.offset = (bfd_vma) -1;
1931     }
1932   else if (h->got.refcount > 0)
1933     {
1934       asection *s;
1935       bfd_boolean dyn;
1936       int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
1937
1938       /* Make sure this symbol is output as a dynamic symbol.
1939          Undefined weak syms won't yet be marked as dynamic.  */
1940       if (h->dynindx == -1
1941           && !h->forced_local)
1942         {
1943           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1944             return FALSE;
1945         }
1946
1947       if (GOT_TLS_GDESC_P (tls_type))
1948         {
1949           eh->tlsdesc_got = htab->sgotplt->size
1950             - elf64_x86_64_compute_jump_table_size (htab);
1951           htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
1952           h->got.offset = (bfd_vma) -2;
1953         }
1954       if (! GOT_TLS_GDESC_P (tls_type)
1955           || GOT_TLS_GD_P (tls_type))
1956         {
1957           s = htab->sgot;
1958           h->got.offset = s->size;
1959           s->size += GOT_ENTRY_SIZE;
1960           if (GOT_TLS_GD_P (tls_type))
1961             s->size += GOT_ENTRY_SIZE;
1962         }
1963       dyn = htab->elf.dynamic_sections_created;
1964       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1965          and two if global.
1966          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
1967       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1968           || tls_type == GOT_TLS_IE)
1969         htab->srelgot->size += sizeof (Elf64_External_Rela);
1970       else if (GOT_TLS_GD_P (tls_type))
1971         htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
1972       else if (! GOT_TLS_GDESC_P (tls_type)
1973                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1974                    || h->root.type != bfd_link_hash_undefweak)
1975                && (info->shared
1976                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1977         htab->srelgot->size += sizeof (Elf64_External_Rela);
1978       if (GOT_TLS_GDESC_P (tls_type))
1979         {
1980           htab->srelplt->size += sizeof (Elf64_External_Rela);
1981           htab->tlsdesc_plt = (bfd_vma) -1;
1982         }
1983     }
1984   else
1985     h->got.offset = (bfd_vma) -1;
1986
1987 skip_relgot:
1988   if (eh->dyn_relocs == NULL)
1989     return TRUE;
1990
1991   /* In the shared -Bsymbolic case, discard space allocated for
1992      dynamic pc-relative relocs against symbols which turn out to be
1993      defined in regular objects.  For the normal shared case, discard
1994      space for pc-relative relocs that have become local due to symbol
1995      visibility changes.  */
1996
1997   if (info->shared)
1998     {
1999       /* Relocs that use pc_count are those that appear on a call
2000          insn, or certain REL relocs that can generated via assembly.
2001          We want calls to protected symbols to resolve directly to the
2002          function rather than going via the plt.  If people want
2003          function pointer comparisons to work as expected then they
2004          should avoid writing weird assembly.  */
2005       if (SYMBOL_CALLS_LOCAL (info, h))
2006         {
2007           struct elf64_x86_64_dyn_relocs **pp;
2008
2009           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2010             {
2011               p->count -= p->pc_count;
2012               p->pc_count = 0;
2013               if (p->count == 0)
2014                 *pp = p->next;
2015               else
2016                 pp = &p->next;
2017             }
2018         }
2019
2020       /* Also discard relocs on undefined weak syms with non-default
2021          visibility.  */
2022       if (eh->dyn_relocs != NULL
2023           && h->root.type == bfd_link_hash_undefweak)
2024         {
2025           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2026             eh->dyn_relocs = NULL;
2027
2028           /* Make sure undefined weak symbols are output as a dynamic
2029              symbol in PIEs.  */
2030           else if (h->dynindx == -1
2031                    && ! h->forced_local
2032                    && ! bfd_elf_link_record_dynamic_symbol (info, h))
2033             return FALSE;
2034         }
2035
2036     }
2037   else if (ELIMINATE_COPY_RELOCS)
2038     {
2039       /* For the non-shared case, discard space for relocs against
2040          symbols which turn out to need copy relocs or are not
2041          dynamic.  */
2042
2043       if (!h->non_got_ref
2044           && ((h->def_dynamic
2045                && !h->def_regular)
2046               || (htab->elf.dynamic_sections_created
2047                   && (h->root.type == bfd_link_hash_undefweak
2048                       || h->root.type == bfd_link_hash_undefined))))
2049         {
2050           /* Make sure this symbol is output as a dynamic symbol.
2051              Undefined weak syms won't yet be marked as dynamic.  */
2052           if (h->dynindx == -1
2053               && ! h->forced_local
2054               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2055             return FALSE;
2056
2057           /* If that succeeded, we know we'll be keeping all the
2058              relocs.  */
2059           if (h->dynindx != -1)
2060             goto keep;
2061         }
2062
2063       eh->dyn_relocs = NULL;
2064
2065     keep: ;
2066     }
2067
2068   /* Finally, allocate space.  */
2069   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2070     {
2071       asection * sreloc;
2072
2073       sreloc = elf_section_data (p->sec)->sreloc;
2074
2075       BFD_ASSERT (sreloc != NULL);
2076
2077       sreloc->size += p->count * sizeof (Elf64_External_Rela);
2078     }
2079
2080   return TRUE;
2081 }
2082
2083 /* Find any dynamic relocs that apply to read-only sections.  */
2084
2085 static bfd_boolean
2086 elf64_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2087 {
2088   struct elf64_x86_64_link_hash_entry *eh;
2089   struct elf64_x86_64_dyn_relocs *p;
2090
2091   if (h->root.type == bfd_link_hash_warning)
2092     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2093
2094   eh = (struct elf64_x86_64_link_hash_entry *) h;
2095   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2096     {
2097       asection *s = p->sec->output_section;
2098
2099       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2100         {
2101           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2102
2103           info->flags |= DF_TEXTREL;
2104
2105           /* Not an error, just cut short the traversal.  */
2106           return FALSE;
2107         }
2108     }
2109   return TRUE;
2110 }
2111
2112 /* Set the sizes of the dynamic sections.  */
2113
2114 static bfd_boolean
2115 elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2116                                     struct bfd_link_info *info)
2117 {
2118   struct elf64_x86_64_link_hash_table *htab;
2119   bfd *dynobj;
2120   asection *s;
2121   bfd_boolean relocs;
2122   bfd *ibfd;
2123
2124   htab = elf64_x86_64_hash_table (info);
2125   dynobj = htab->elf.dynobj;
2126   if (dynobj == NULL)
2127     abort ();
2128
2129   if (htab->elf.dynamic_sections_created)
2130     {
2131       /* Set the contents of the .interp section to the interpreter.  */
2132       if (info->executable)
2133         {
2134           s = bfd_get_section_by_name (dynobj, ".interp");
2135           if (s == NULL)
2136             abort ();
2137           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2138           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2139         }
2140     }
2141
2142   /* Set up .got offsets for local syms, and space for local dynamic
2143      relocs.  */
2144   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2145     {
2146       bfd_signed_vma *local_got;
2147       bfd_signed_vma *end_local_got;
2148       char *local_tls_type;
2149       bfd_vma *local_tlsdesc_gotent;
2150       bfd_size_type locsymcount;
2151       Elf_Internal_Shdr *symtab_hdr;
2152       asection *srel;
2153
2154       if (! is_x86_64_elf (ibfd))
2155         continue;
2156
2157       for (s = ibfd->sections; s != NULL; s = s->next)
2158         {
2159           struct elf64_x86_64_dyn_relocs *p;
2160
2161           for (p = (struct elf64_x86_64_dyn_relocs *)
2162                     (elf_section_data (s)->local_dynrel);
2163                p != NULL;
2164                p = p->next)
2165             {
2166               if (!bfd_is_abs_section (p->sec)
2167                   && bfd_is_abs_section (p->sec->output_section))
2168                 {
2169                   /* Input section has been discarded, either because
2170                      it is a copy of a linkonce section or due to
2171                      linker script /DISCARD/, so we'll be discarding
2172                      the relocs too.  */
2173                 }
2174               else if (p->count != 0)
2175                 {
2176                   srel = elf_section_data (p->sec)->sreloc;
2177                   srel->size += p->count * sizeof (Elf64_External_Rela);
2178                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2179                     info->flags |= DF_TEXTREL;
2180                 }
2181             }
2182         }
2183
2184       local_got = elf_local_got_refcounts (ibfd);
2185       if (!local_got)
2186         continue;
2187
2188       symtab_hdr = &elf_symtab_hdr (ibfd);
2189       locsymcount = symtab_hdr->sh_info;
2190       end_local_got = local_got + locsymcount;
2191       local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
2192       local_tlsdesc_gotent = elf64_x86_64_local_tlsdesc_gotent (ibfd);
2193       s = htab->sgot;
2194       srel = htab->srelgot;
2195       for (; local_got < end_local_got;
2196            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2197         {
2198           *local_tlsdesc_gotent = (bfd_vma) -1;
2199           if (*local_got > 0)
2200             {
2201               if (GOT_TLS_GDESC_P (*local_tls_type))
2202                 {
2203                   *local_tlsdesc_gotent = htab->sgotplt->size
2204                     - elf64_x86_64_compute_jump_table_size (htab);
2205                   htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
2206                   *local_got = (bfd_vma) -2;
2207                 }
2208               if (! GOT_TLS_GDESC_P (*local_tls_type)
2209                   || GOT_TLS_GD_P (*local_tls_type))
2210                 {
2211                   *local_got = s->size;
2212                   s->size += GOT_ENTRY_SIZE;
2213                   if (GOT_TLS_GD_P (*local_tls_type))
2214                     s->size += GOT_ENTRY_SIZE;
2215                 }
2216               if (info->shared
2217                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2218                   || *local_tls_type == GOT_TLS_IE)
2219                 {
2220                   if (GOT_TLS_GDESC_P (*local_tls_type))
2221                     {
2222                       htab->srelplt->size += sizeof (Elf64_External_Rela);
2223                       htab->tlsdesc_plt = (bfd_vma) -1;
2224                     }
2225                   if (! GOT_TLS_GDESC_P (*local_tls_type)
2226                       || GOT_TLS_GD_P (*local_tls_type))
2227                     srel->size += sizeof (Elf64_External_Rela);
2228                 }
2229             }
2230           else
2231             *local_got = (bfd_vma) -1;
2232         }
2233     }
2234
2235   if (htab->tls_ld_got.refcount > 0)
2236     {
2237       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2238          relocs.  */
2239       htab->tls_ld_got.offset = htab->sgot->size;
2240       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
2241       htab->srelgot->size += sizeof (Elf64_External_Rela);
2242     }
2243   else
2244     htab->tls_ld_got.offset = -1;
2245
2246   /* Allocate global sym .plt and .got entries, and space for global
2247      sym dynamic relocs.  */
2248   elf_link_hash_traverse (&htab->elf, elf64_x86_64_allocate_dynrelocs,
2249                           info);
2250
2251   /* For every jump slot reserved in the sgotplt, reloc_count is
2252      incremented.  However, when we reserve space for TLS descriptors,
2253      it's not incremented, so in order to compute the space reserved
2254      for them, it suffices to multiply the reloc count by the jump
2255      slot size.  */
2256   if (htab->srelplt)
2257     htab->sgotplt_jump_table_size
2258       = elf64_x86_64_compute_jump_table_size (htab);
2259
2260   if (htab->tlsdesc_plt)
2261     {
2262       /* If we're not using lazy TLS relocations, don't generate the
2263          PLT and GOT entries they require.  */
2264       if ((info->flags & DF_BIND_NOW))
2265         htab->tlsdesc_plt = 0;
2266       else
2267         {
2268           htab->tlsdesc_got = htab->sgot->size;
2269           htab->sgot->size += GOT_ENTRY_SIZE;
2270           /* Reserve room for the initial entry.
2271              FIXME: we could probably do away with it in this case.  */
2272           if (htab->splt->size == 0)
2273             htab->splt->size += PLT_ENTRY_SIZE;
2274           htab->tlsdesc_plt = htab->splt->size;
2275           htab->splt->size += PLT_ENTRY_SIZE;
2276         }
2277     }
2278
2279   /* We now have determined the sizes of the various dynamic sections.
2280      Allocate memory for them.  */
2281   relocs = FALSE;
2282   for (s = dynobj->sections; s != NULL; s = s->next)
2283     {
2284       if ((s->flags & SEC_LINKER_CREATED) == 0)
2285         continue;
2286
2287       if (s == htab->splt
2288           || s == htab->sgot
2289           || s == htab->sgotplt
2290           || s == htab->iplt
2291           || s == htab->igotplt
2292           || s == htab->sdynbss)
2293         {
2294           /* Strip this section if we don't need it; see the
2295              comment below.  */
2296         }
2297       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2298         {
2299           if (s->size != 0 && s != htab->srelplt)
2300             relocs = TRUE;
2301
2302           /* We use the reloc_count field as a counter if we need
2303              to copy relocs into the output file.  */
2304           if (s != htab->srelplt)
2305             s->reloc_count = 0;
2306         }
2307       else
2308         {
2309           /* It's not one of our sections, so don't allocate space.  */
2310           continue;
2311         }
2312
2313       if (s->size == 0)
2314         {
2315           /* If we don't need this section, strip it from the
2316              output file.  This is mostly to handle .rela.bss and
2317              .rela.plt.  We must create both sections in
2318              create_dynamic_sections, because they must be created
2319              before the linker maps input sections to output
2320              sections.  The linker does that before
2321              adjust_dynamic_symbol is called, and it is that
2322              function which decides whether anything needs to go
2323              into these sections.  */
2324
2325           s->flags |= SEC_EXCLUDE;
2326           continue;
2327         }
2328
2329       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2330         continue;
2331
2332       /* Allocate memory for the section contents.  We use bfd_zalloc
2333          here in case unused entries are not reclaimed before the
2334          section's contents are written out.  This should not happen,
2335          but this way if it does, we get a R_X86_64_NONE reloc instead
2336          of garbage.  */
2337       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2338       if (s->contents == NULL)
2339         return FALSE;
2340     }
2341
2342   if (htab->elf.dynamic_sections_created)
2343     {
2344       /* Add some entries to the .dynamic section.  We fill in the
2345          values later, in elf64_x86_64_finish_dynamic_sections, but we
2346          must add the entries now so that we get the correct size for
2347          the .dynamic section.  The DT_DEBUG entry is filled in by the
2348          dynamic linker and used by the debugger.  */
2349 #define add_dynamic_entry(TAG, VAL) \
2350   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2351
2352       if (info->executable)
2353         {
2354           if (!add_dynamic_entry (DT_DEBUG, 0))
2355             return FALSE;
2356         }
2357
2358       if (htab->splt->size != 0)
2359         {
2360           if (!add_dynamic_entry (DT_PLTGOT, 0)
2361               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2362               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2363               || !add_dynamic_entry (DT_JMPREL, 0))
2364             return FALSE;
2365
2366           if (htab->tlsdesc_plt
2367               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2368                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2369             return FALSE;
2370         }
2371
2372       if (relocs)
2373         {
2374           if (!add_dynamic_entry (DT_RELA, 0)
2375               || !add_dynamic_entry (DT_RELASZ, 0)
2376               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2377             return FALSE;
2378
2379           /* If any dynamic relocs apply to a read-only section,
2380              then we need a DT_TEXTREL entry.  */
2381           if ((info->flags & DF_TEXTREL) == 0)
2382             elf_link_hash_traverse (&htab->elf,
2383                                     elf64_x86_64_readonly_dynrelocs,
2384                                     info);
2385
2386           if ((info->flags & DF_TEXTREL) != 0)
2387             {
2388               if (!add_dynamic_entry (DT_TEXTREL, 0))
2389                 return FALSE;
2390             }
2391         }
2392     }
2393 #undef add_dynamic_entry
2394
2395   return TRUE;
2396 }
2397
2398 static bfd_boolean
2399 elf64_x86_64_always_size_sections (bfd *output_bfd,
2400                                    struct bfd_link_info *info)
2401 {
2402   asection *tls_sec = elf_hash_table (info)->tls_sec;
2403
2404   if (tls_sec)
2405     {
2406       struct elf_link_hash_entry *tlsbase;
2407
2408       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2409                                       "_TLS_MODULE_BASE_",
2410                                       FALSE, FALSE, FALSE);
2411
2412       if (tlsbase && tlsbase->type == STT_TLS)
2413         {
2414           struct bfd_link_hash_entry *bh = NULL;
2415           const struct elf_backend_data *bed
2416             = get_elf_backend_data (output_bfd);
2417
2418           if (!(_bfd_generic_link_add_one_symbol
2419                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2420                  tls_sec, 0, NULL, FALSE,
2421                  bed->collect, &bh)))
2422             return FALSE;
2423
2424           elf64_x86_64_hash_table (info)->tls_module_base = bh;
2425
2426           tlsbase = (struct elf_link_hash_entry *)bh;
2427           tlsbase->def_regular = 1;
2428           tlsbase->other = STV_HIDDEN;
2429           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2430         }
2431     }
2432
2433   return TRUE;
2434 }
2435
2436 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2437    executables.  Rather than setting it to the beginning of the TLS
2438    section, we have to set it to the end.  This function may be called
2439    multiple times, it is idempotent.  */
2440
2441 static void
2442 elf64_x86_64_set_tls_module_base (struct bfd_link_info *info)
2443 {
2444   struct bfd_link_hash_entry *base;
2445
2446   if (!info->executable)
2447     return;
2448
2449   base = elf64_x86_64_hash_table (info)->tls_module_base;
2450
2451   if (!base)
2452     return;
2453
2454   base->u.def.value = elf_hash_table (info)->tls_size;
2455 }
2456
2457 /* Return the base VMA address which should be subtracted from real addresses
2458    when resolving @dtpoff relocation.
2459    This is PT_TLS segment p_vaddr.  */
2460
2461 static bfd_vma
2462 elf64_x86_64_dtpoff_base (struct bfd_link_info *info)
2463 {
2464   /* If tls_sec is NULL, we should have signalled an error already.  */
2465   if (elf_hash_table (info)->tls_sec == NULL)
2466     return 0;
2467   return elf_hash_table (info)->tls_sec->vma;
2468 }
2469
2470 /* Return the relocation value for @tpoff relocation
2471    if STT_TLS virtual address is ADDRESS.  */
2472
2473 static bfd_vma
2474 elf64_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2475 {
2476   struct elf_link_hash_table *htab = elf_hash_table (info);
2477
2478   /* If tls_segment is NULL, we should have signalled an error already.  */
2479   if (htab->tls_sec == NULL)
2480     return 0;
2481   return address - htab->tls_size - htab->tls_sec->vma;
2482 }
2483
2484 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2485    branch?  */
2486
2487 static bfd_boolean
2488 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2489 {
2490   /* Opcode             Instruction
2491      0xe8               call
2492      0xe9               jump
2493      0x0f 0x8x          conditional jump */
2494   return ((offset > 0
2495            && (contents [offset - 1] == 0xe8
2496                || contents [offset - 1] == 0xe9))
2497           || (offset > 1
2498               && contents [offset - 2] == 0x0f
2499               && (contents [offset - 1] & 0xf0) == 0x80));
2500 }
2501
2502 /* Relocate an x86_64 ELF section.  */
2503
2504 static bfd_boolean
2505 elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2506                                bfd *input_bfd, asection *input_section,
2507                                bfd_byte *contents, Elf_Internal_Rela *relocs,
2508                                Elf_Internal_Sym *local_syms,
2509                                asection **local_sections)
2510 {
2511   struct elf64_x86_64_link_hash_table *htab;
2512   Elf_Internal_Shdr *symtab_hdr;
2513   struct elf_link_hash_entry **sym_hashes;
2514   bfd_vma *local_got_offsets;
2515   bfd_vma *local_tlsdesc_gotents;
2516   Elf_Internal_Rela *rel;
2517   Elf_Internal_Rela *relend;
2518
2519   BFD_ASSERT (is_x86_64_elf (input_bfd));
2520
2521   htab = elf64_x86_64_hash_table (info);
2522   symtab_hdr = &elf_symtab_hdr (input_bfd);
2523   sym_hashes = elf_sym_hashes (input_bfd);
2524   local_got_offsets = elf_local_got_offsets (input_bfd);
2525   local_tlsdesc_gotents = elf64_x86_64_local_tlsdesc_gotent (input_bfd);
2526
2527   elf64_x86_64_set_tls_module_base (info);
2528
2529   rel = relocs;
2530   relend = relocs + input_section->reloc_count;
2531   for (; rel < relend; rel++)
2532     {
2533       unsigned int r_type;
2534       reloc_howto_type *howto;
2535       unsigned long r_symndx;
2536       struct elf_link_hash_entry *h;
2537       Elf_Internal_Sym *sym;
2538       asection *sec;
2539       bfd_vma off, offplt;
2540       bfd_vma relocation;
2541       bfd_boolean unresolved_reloc;
2542       bfd_reloc_status_type r;
2543       int tls_type;
2544       asection *base_got;
2545
2546       r_type = ELF64_R_TYPE (rel->r_info);
2547       if (r_type == (int) R_X86_64_GNU_VTINHERIT
2548           || r_type == (int) R_X86_64_GNU_VTENTRY)
2549         continue;
2550
2551       if (r_type >= R_X86_64_max)
2552         {
2553           bfd_set_error (bfd_error_bad_value);
2554           return FALSE;
2555         }
2556
2557       howto = x86_64_elf_howto_table + r_type;
2558       r_symndx = ELF64_R_SYM (rel->r_info);
2559       h = NULL;
2560       sym = NULL;
2561       sec = NULL;
2562       unresolved_reloc = FALSE;
2563       if (r_symndx < symtab_hdr->sh_info)
2564         {
2565           sym = local_syms + r_symndx;
2566           sec = local_sections[r_symndx];
2567
2568           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2569         }
2570       else
2571         {
2572           bfd_boolean warned;
2573
2574           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2575                                    r_symndx, symtab_hdr, sym_hashes,
2576                                    h, sec, relocation,
2577                                    unresolved_reloc, warned);
2578         }
2579
2580       if (sec != NULL && elf_discarded_section (sec))
2581         {
2582           /* For relocs against symbols from removed linkonce sections,
2583              or sections discarded by a linker script, we just want the
2584              section contents zeroed.  Avoid any special processing.  */
2585           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2586           rel->r_info = 0;
2587           rel->r_addend = 0;
2588           continue;
2589         }
2590
2591       if (info->relocatable)
2592         continue;
2593
2594       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2595          it here if it is defined in a non-shared object.  */
2596       if (h != NULL
2597           && h->type == STT_GNU_IFUNC
2598           && h->def_regular)
2599         {
2600           asection *plt;
2601           bfd_vma plt_index;
2602
2603           if ((input_section->flags & SEC_ALLOC) == 0
2604               || h->plt.offset == (bfd_vma) -1)
2605             abort ();
2606
2607           /* STT_GNU_IFUNC symbol must go through PLT.  */
2608           plt = htab->splt ? htab->splt : htab->iplt;
2609           relocation = (plt->output_section->vma
2610                         + plt->output_offset + h->plt.offset);
2611
2612           switch (r_type)
2613             {
2614             default:
2615               (*_bfd_error_handler)
2616                 (_("%B: relocation %s against STT_GNU_IFUNC "
2617                    "symbol `%s' isn't handled by %s"), input_bfd,
2618                  x86_64_elf_howto_table[r_type].name,
2619                  h->root.root.string, __FUNCTION__);
2620               bfd_set_error (bfd_error_bad_value);
2621               return FALSE;
2622
2623             case R_X86_64_32S:
2624               if (!info->executable)
2625                 abort ();
2626
2627             case R_X86_64_32:
2628             case R_X86_64_64:
2629             case R_X86_64_PC32:
2630             case R_X86_64_PC64:
2631             case R_X86_64_PLT32:
2632               goto do_relocation;
2633
2634             case R_X86_64_GOTPCREL:
2635             case R_X86_64_GOTPCREL64:
2636               base_got = htab->sgot;
2637               off = h->got.offset;
2638
2639               if (base_got == NULL)
2640                 abort ();
2641
2642               if (off == (bfd_vma) -1)
2643                 {
2644                   /* We can't use h->got.offset here to save state, or
2645                      even just remember the offset, as finish_dynamic_symbol
2646                      would use that as offset into .got.  */
2647
2648                   if (htab->splt != NULL)
2649                     {
2650                       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2651                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
2652                       base_got = htab->sgotplt;
2653                     }
2654                   else
2655                     {
2656                       plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2657                       off = plt_index * GOT_ENTRY_SIZE;
2658                       base_got = htab->igotplt;
2659                     }
2660
2661                   if (h->dynindx == -1
2662                       || h->forced_local
2663                       || info->symbolic)
2664                     {
2665                       /* This references the local defitionion.  We must
2666                          initialize this entry in the global offset table.
2667                          Since the offset must always be a multiple of 8,
2668                          we use the least significant bit to record
2669                          whether we have initialized it already.
2670
2671                          When doing a dynamic link, we create a .rela.got
2672                          relocation entry to initialize the value.  This
2673                          is done in the finish_dynamic_symbol routine.   */
2674                       if ((off & 1) != 0)
2675                         off &= ~1;
2676                       else
2677                         {
2678                           bfd_put_64 (output_bfd, relocation,
2679                                       base_got->contents + off);
2680                           /* Note that this is harmless for the GOTPLT64
2681                              case, as -1 | 1 still is -1.  */
2682                           h->got.offset |= 1;
2683                         }
2684                     }
2685                 }
2686
2687               relocation = (base_got->output_section->vma
2688                             + base_got->output_offset + off);
2689
2690               if (r_type != R_X86_64_GOTPCREL
2691                   && r_type != R_X86_64_GOTPCREL64)
2692                 {
2693                   asection *gotplt;
2694                   if (htab->splt != NULL)
2695                     gotplt = htab->sgotplt;
2696                   else
2697                     gotplt = htab->igotplt;
2698                   relocation -= (gotplt->output_section->vma
2699                                  - gotplt->output_offset);
2700                 }
2701
2702               goto do_relocation;
2703             }
2704         }
2705
2706       /* When generating a shared object, the relocations handled here are
2707          copied into the output file to be resolved at run time.  */
2708       switch (r_type)
2709         {
2710         case R_X86_64_GOT32:
2711         case R_X86_64_GOT64:
2712           /* Relocation is to the entry for this symbol in the global
2713              offset table.  */
2714         case R_X86_64_GOTPCREL:
2715         case R_X86_64_GOTPCREL64:
2716           /* Use global offset table entry as symbol value.  */
2717         case R_X86_64_GOTPLT64:
2718           /* This is the same as GOT64 for relocation purposes, but
2719              indicates the existence of a PLT entry.  The difficulty is,
2720              that we must calculate the GOT slot offset from the PLT
2721              offset, if this symbol got a PLT entry (it was global).
2722              Additionally if it's computed from the PLT entry, then that
2723              GOT offset is relative to .got.plt, not to .got.  */
2724           base_got = htab->sgot;
2725
2726           if (htab->sgot == NULL)
2727             abort ();
2728
2729           if (h != NULL)
2730             {
2731               bfd_boolean dyn;
2732
2733               off = h->got.offset;
2734               if (h->needs_plt
2735                   && h->plt.offset != (bfd_vma)-1
2736                   && off == (bfd_vma)-1)
2737                 {
2738                   /* We can't use h->got.offset here to save
2739                      state, or even just remember the offset, as
2740                      finish_dynamic_symbol would use that as offset into
2741                      .got.  */
2742                   bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2743                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
2744                   base_got = htab->sgotplt;
2745                 }
2746
2747               dyn = htab->elf.dynamic_sections_created;
2748
2749               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2750                   || (info->shared
2751                       && SYMBOL_REFERENCES_LOCAL (info, h))
2752                   || (ELF_ST_VISIBILITY (h->other)
2753                       && h->root.type == bfd_link_hash_undefweak))
2754                 {
2755                   /* This is actually a static link, or it is a -Bsymbolic
2756                      link and the symbol is defined locally, or the symbol
2757                      was forced to be local because of a version file.  We
2758                      must initialize this entry in the global offset table.
2759                      Since the offset must always be a multiple of 8, we
2760                      use the least significant bit to record whether we
2761                      have initialized it already.
2762
2763                      When doing a dynamic link, we create a .rela.got
2764                      relocation entry to initialize the value.  This is
2765                      done in the finish_dynamic_symbol routine.  */
2766                   if ((off & 1) != 0)
2767                     off &= ~1;
2768                   else
2769                     {
2770                       bfd_put_64 (output_bfd, relocation,
2771                                   base_got->contents + off);
2772                       /* Note that this is harmless for the GOTPLT64 case,
2773                          as -1 | 1 still is -1.  */
2774                       h->got.offset |= 1;
2775                     }
2776                 }
2777               else
2778                 unresolved_reloc = FALSE;
2779             }
2780           else
2781             {
2782               if (local_got_offsets == NULL)
2783                 abort ();
2784
2785               off = local_got_offsets[r_symndx];
2786
2787               /* The offset must always be a multiple of 8.  We use
2788                  the least significant bit to record whether we have
2789                  already generated the necessary reloc.  */
2790               if ((off & 1) != 0)
2791                 off &= ~1;
2792               else
2793                 {
2794                   bfd_put_64 (output_bfd, relocation,
2795                               base_got->contents + off);
2796
2797                   if (info->shared)
2798                     {
2799                       asection *s;
2800                       Elf_Internal_Rela outrel;
2801                       bfd_byte *loc;
2802
2803                       /* We need to generate a R_X86_64_RELATIVE reloc
2804                          for the dynamic linker.  */
2805                       s = htab->srelgot;
2806                       if (s == NULL)
2807                         abort ();
2808
2809                       outrel.r_offset = (base_got->output_section->vma
2810                                          + base_got->output_offset
2811                                          + off);
2812                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2813                       outrel.r_addend = relocation;
2814                       loc = s->contents;
2815                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2816                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2817                     }
2818
2819                   local_got_offsets[r_symndx] |= 1;
2820                 }
2821             }
2822
2823           if (off >= (bfd_vma) -2)
2824             abort ();
2825
2826           relocation = base_got->output_section->vma
2827                        + base_got->output_offset + off;
2828           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
2829             relocation -= htab->sgotplt->output_section->vma
2830                           - htab->sgotplt->output_offset;
2831
2832           break;
2833
2834         case R_X86_64_GOTOFF64:
2835           /* Relocation is relative to the start of the global offset
2836              table.  */
2837
2838           /* Check to make sure it isn't a protected function symbol
2839              for shared library since it may not be local when used
2840              as function address.  */
2841           if (info->shared
2842               && h
2843               && h->def_regular
2844               && h->type == STT_FUNC
2845               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2846             {
2847               (*_bfd_error_handler)
2848                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
2849                  input_bfd, h->root.root.string);
2850               bfd_set_error (bfd_error_bad_value);
2851               return FALSE;
2852             }
2853
2854           /* Note that sgot is not involved in this
2855              calculation.  We always want the start of .got.plt.  If we
2856              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2857              permitted by the ABI, we might have to change this
2858              calculation.  */
2859           relocation -= htab->sgotplt->output_section->vma
2860                         + htab->sgotplt->output_offset;
2861           break;
2862
2863         case R_X86_64_GOTPC32:
2864         case R_X86_64_GOTPC64:
2865           /* Use global offset table as symbol value.  */
2866           relocation = htab->sgotplt->output_section->vma
2867                        + htab->sgotplt->output_offset;
2868           unresolved_reloc = FALSE;
2869           break;
2870
2871         case R_X86_64_PLTOFF64:
2872           /* Relocation is PLT entry relative to GOT.  For local
2873              symbols it's the symbol itself relative to GOT.  */
2874           if (h != NULL
2875               /* See PLT32 handling.  */
2876               && h->plt.offset != (bfd_vma) -1
2877               && htab->splt != NULL)
2878             {
2879               relocation = (htab->splt->output_section->vma
2880                             + htab->splt->output_offset
2881                             + h->plt.offset);
2882               unresolved_reloc = FALSE;
2883             }
2884
2885           relocation -= htab->sgotplt->output_section->vma
2886                         + htab->sgotplt->output_offset;
2887           break;
2888
2889         case R_X86_64_PLT32:
2890           /* Relocation is to the entry for this symbol in the
2891              procedure linkage table.  */
2892
2893           /* Resolve a PLT32 reloc against a local symbol directly,
2894              without using the procedure linkage table.  */
2895           if (h == NULL)
2896             break;
2897
2898           if (h->plt.offset == (bfd_vma) -1
2899               || htab->splt == NULL)
2900             {
2901               /* We didn't make a PLT entry for this symbol.  This
2902                  happens when statically linking PIC code, or when
2903                  using -Bsymbolic.  */
2904               break;
2905             }
2906
2907           relocation = (htab->splt->output_section->vma
2908                         + htab->splt->output_offset
2909                         + h->plt.offset);
2910           unresolved_reloc = FALSE;
2911           break;
2912
2913         case R_X86_64_PC8:
2914         case R_X86_64_PC16:
2915         case R_X86_64_PC32:
2916           if (info->shared
2917               && (input_section->flags & SEC_ALLOC) != 0
2918               && (input_section->flags & SEC_READONLY) != 0
2919               && h != NULL)
2920             {
2921               bfd_boolean fail = FALSE;
2922               bfd_boolean branch
2923                 = (r_type == R_X86_64_PC32
2924                    && is_32bit_relative_branch (contents, rel->r_offset));
2925
2926               if (SYMBOL_REFERENCES_LOCAL (info, h))
2927                 {
2928                   /* Symbol is referenced locally.  Make sure it is
2929                      defined locally or for a branch.  */
2930                   fail = !h->def_regular && !branch;
2931                 }
2932               else
2933                 {
2934                   /* Symbol isn't referenced locally.  We only allow
2935                      branch to symbol with non-default visibility. */
2936                   fail = (!branch
2937                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
2938                 }
2939
2940               if (fail)
2941                 {
2942                   const char *fmt;
2943                   const char *v;
2944                   const char *pic = "";
2945
2946                   switch (ELF_ST_VISIBILITY (h->other))
2947                     {
2948                     case STV_HIDDEN:
2949                       v = _("hidden symbol");
2950                       break;
2951                     case STV_INTERNAL:
2952                       v = _("internal symbol");
2953                       break;
2954                     case STV_PROTECTED:
2955                       v = _("protected symbol");
2956                       break;
2957                     default:
2958                       v = _("symbol");
2959                       pic = _("; recompile with -fPIC");
2960                       break;
2961                     }
2962
2963                   if (h->def_regular)
2964                     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
2965                   else
2966                     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
2967
2968                   (*_bfd_error_handler) (fmt, input_bfd,
2969                                          x86_64_elf_howto_table[r_type].name,
2970                                          v,  h->root.root.string, pic);
2971                   bfd_set_error (bfd_error_bad_value);
2972                   return FALSE;
2973                 }
2974             }
2975           /* Fall through.  */
2976
2977         case R_X86_64_8:
2978         case R_X86_64_16:
2979         case R_X86_64_32:
2980         case R_X86_64_PC64:
2981         case R_X86_64_64:
2982           /* FIXME: The ABI says the linker should make sure the value is
2983              the same when it's zeroextended to 64 bit.  */
2984
2985           if ((input_section->flags & SEC_ALLOC) == 0)
2986             break;
2987
2988           if ((info->shared
2989                && (h == NULL
2990                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2991                    || h->root.type != bfd_link_hash_undefweak)
2992                && (! IS_X86_64_PCREL_TYPE (r_type)
2993                    || ! SYMBOL_CALLS_LOCAL (info, h)))
2994               || (ELIMINATE_COPY_RELOCS
2995                   && !info->shared
2996                   && h != NULL
2997                   && h->dynindx != -1
2998                   && !h->non_got_ref
2999                   && ((h->def_dynamic
3000                        && !h->def_regular)
3001                       || h->root.type == bfd_link_hash_undefweak
3002                       || h->root.type == bfd_link_hash_undefined)))
3003             {
3004               Elf_Internal_Rela outrel;
3005               bfd_byte *loc;
3006               bfd_boolean skip, relocate;
3007               asection *sreloc;
3008
3009               /* When generating a shared object, these relocations
3010                  are copied into the output file to be resolved at run
3011                  time.  */
3012               skip = FALSE;
3013               relocate = FALSE;
3014
3015               outrel.r_offset =
3016                 _bfd_elf_section_offset (output_bfd, info, input_section,
3017                                          rel->r_offset);
3018               if (outrel.r_offset == (bfd_vma) -1)
3019                 skip = TRUE;
3020               else if (outrel.r_offset == (bfd_vma) -2)
3021                 skip = TRUE, relocate = TRUE;
3022
3023               outrel.r_offset += (input_section->output_section->vma
3024                                   + input_section->output_offset);
3025
3026               if (skip)
3027                 memset (&outrel, 0, sizeof outrel);
3028
3029               /* h->dynindx may be -1 if this symbol was marked to
3030                  become local.  */
3031               else if (h != NULL
3032                        && h->dynindx != -1
3033                        && (IS_X86_64_PCREL_TYPE (r_type)
3034                            || ! info->shared
3035                            || ! SYMBOLIC_BIND (info, h)
3036                            || ! h->def_regular))
3037                 {
3038                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
3039                   outrel.r_addend = rel->r_addend;
3040                 }
3041               else
3042                 {
3043                   /* This symbol is local, or marked to become local.  */
3044                   if (r_type == R_X86_64_64)
3045                     {
3046                       relocate = TRUE;
3047                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
3048                       outrel.r_addend = relocation + rel->r_addend;
3049                     }
3050                   else
3051                     {
3052                       long sindx;
3053
3054                       if (bfd_is_abs_section (sec))
3055                         sindx = 0;
3056                       else if (sec == NULL || sec->owner == NULL)
3057                         {
3058                           bfd_set_error (bfd_error_bad_value);
3059                           return FALSE;
3060                         }
3061                       else
3062                         {
3063                           asection *osec;
3064
3065                           /* We are turning this relocation into one
3066                              against a section symbol.  It would be
3067                              proper to subtract the symbol's value,
3068                              osec->vma, from the emitted reloc addend,
3069                              but ld.so expects buggy relocs.  */
3070                           osec = sec->output_section;
3071                           sindx = elf_section_data (osec)->dynindx;
3072                           if (sindx == 0)
3073                             {
3074                               asection *oi = htab->elf.text_index_section;
3075                               sindx = elf_section_data (oi)->dynindx;
3076                             }
3077                           BFD_ASSERT (sindx != 0);
3078                         }
3079
3080                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
3081                       outrel.r_addend = relocation + rel->r_addend;
3082                     }
3083                 }
3084
3085               sreloc = elf_section_data (input_section)->sreloc;
3086
3087               BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
3088
3089               loc = sreloc->contents;
3090               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3091               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3092
3093               /* If this reloc is against an external symbol, we do
3094                  not want to fiddle with the addend.  Otherwise, we
3095                  need to include the symbol value so that it becomes
3096                  an addend for the dynamic reloc.  */
3097               if (! relocate)
3098                 continue;
3099             }
3100
3101           break;
3102
3103         case R_X86_64_TLSGD:
3104         case R_X86_64_GOTPC32_TLSDESC:
3105         case R_X86_64_TLSDESC_CALL:
3106         case R_X86_64_GOTTPOFF:
3107           tls_type = GOT_UNKNOWN;
3108           if (h == NULL && local_got_offsets)
3109             tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3110           else if (h != NULL)
3111             tls_type = elf64_x86_64_hash_entry (h)->tls_type;
3112
3113           if (! elf64_x86_64_tls_transition (info, input_bfd,
3114                                              input_section, contents,
3115                                              symtab_hdr, sym_hashes,
3116                                              &r_type, tls_type, rel,
3117                                              relend, h))
3118             return FALSE;
3119
3120           if (r_type == R_X86_64_TPOFF32)
3121             {
3122               bfd_vma roff = rel->r_offset;
3123
3124               BFD_ASSERT (! unresolved_reloc);
3125
3126               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3127                 {
3128                   /* GD->LE transition.
3129                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3130                      .word 0x6666; rex64; call __tls_get_addr
3131                      Change it into:
3132                      movq %fs:0, %rax
3133                      leaq foo@tpoff(%rax), %rax */
3134                   memcpy (contents + roff - 4,
3135                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3136                           16);
3137                   bfd_put_32 (output_bfd,
3138                               elf64_x86_64_tpoff (info, relocation),
3139                               contents + roff + 8);
3140                   /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3141                   rel++;
3142                   continue;
3143                 }
3144               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3145                 {
3146                   /* GDesc -> LE transition.
3147                      It's originally something like:
3148                      leaq x@tlsdesc(%rip), %rax
3149
3150                      Change it to:
3151                      movl $x@tpoff, %rax
3152                    */
3153
3154                   unsigned int val, type, type2;
3155
3156                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3157                   type2 = bfd_get_8 (input_bfd, contents + roff - 2);
3158                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3159                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3160                              contents + roff - 3);
3161                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3162                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3163                              contents + roff - 1);
3164                   bfd_put_32 (output_bfd,
3165                               elf64_x86_64_tpoff (info, relocation),
3166                               contents + roff);
3167                   continue;
3168                 }
3169               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3170                 {
3171                   /* GDesc -> LE transition.
3172                      It's originally:
3173                      call *(%rax)
3174                      Turn it into:
3175                      xchg %ax,%ax.  */
3176                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3177                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3178                   continue;
3179                 }
3180               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3181                 {
3182                   /* IE->LE transition:
3183                      Originally it can be one of:
3184                      movq foo@gottpoff(%rip), %reg
3185                      addq foo@gottpoff(%rip), %reg
3186                      We change it into:
3187                      movq $foo, %reg
3188                      leaq foo(%reg), %reg
3189                      addq $foo, %reg.  */
3190
3191                   unsigned int val, type, reg;
3192
3193                   val = bfd_get_8 (input_bfd, contents + roff - 3);
3194                   type = bfd_get_8 (input_bfd, contents + roff - 2);
3195                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
3196                   reg >>= 3;
3197                   if (type == 0x8b)
3198                     {
3199                       /* movq */
3200                       if (val == 0x4c)
3201                         bfd_put_8 (output_bfd, 0x49,
3202                                    contents + roff - 3);
3203                       bfd_put_8 (output_bfd, 0xc7,
3204                                  contents + roff - 2);
3205                       bfd_put_8 (output_bfd, 0xc0 | reg,
3206                                  contents + roff - 1);
3207                     }
3208                   else if (reg == 4)
3209                     {
3210                       /* addq -> addq - addressing with %rsp/%r12 is
3211                          special  */
3212                       if (val == 0x4c)
3213                         bfd_put_8 (output_bfd, 0x49,
3214                                    contents + roff - 3);
3215                       bfd_put_8 (output_bfd, 0x81,
3216                                  contents + roff - 2);
3217                       bfd_put_8 (output_bfd, 0xc0 | reg,
3218                                  contents + roff - 1);
3219                     }
3220                   else
3221                     {
3222                       /* addq -> leaq */
3223                       if (val == 0x4c)
3224                         bfd_put_8 (output_bfd, 0x4d,
3225                                    contents + roff - 3);
3226                       bfd_put_8 (output_bfd, 0x8d,
3227                                  contents + roff - 2);
3228                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3229                                  contents + roff - 1);
3230                     }
3231                   bfd_put_32 (output_bfd,
3232                               elf64_x86_64_tpoff (info, relocation),
3233                               contents + roff);
3234                   continue;
3235                 }
3236               else
3237                 BFD_ASSERT (FALSE);
3238             }
3239
3240           if (htab->sgot == NULL)
3241             abort ();
3242
3243           if (h != NULL)
3244             {
3245               off = h->got.offset;
3246               offplt = elf64_x86_64_hash_entry (h)->tlsdesc_got;
3247             }
3248           else
3249             {
3250               if (local_got_offsets == NULL)
3251                 abort ();
3252
3253               off = local_got_offsets[r_symndx];
3254               offplt = local_tlsdesc_gotents[r_symndx];
3255             }
3256
3257           if ((off & 1) != 0)
3258             off &= ~1;
3259           else
3260             {
3261               Elf_Internal_Rela outrel;
3262               bfd_byte *loc;
3263               int dr_type, indx;
3264               asection *sreloc;
3265
3266               if (htab->srelgot == NULL)
3267                 abort ();
3268
3269               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3270
3271               if (GOT_TLS_GDESC_P (tls_type))
3272                 {
3273                   outrel.r_info = ELF64_R_INFO (indx, R_X86_64_TLSDESC);
3274                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3275                               + 2 * GOT_ENTRY_SIZE <= htab->sgotplt->size);
3276                   outrel.r_offset = (htab->sgotplt->output_section->vma
3277                                      + htab->sgotplt->output_offset
3278                                      + offplt
3279                                      + htab->sgotplt_jump_table_size);
3280                   sreloc = htab->srelplt;
3281                   loc = sreloc->contents;
3282                   loc += sreloc->reloc_count++
3283                     * sizeof (Elf64_External_Rela);
3284                   BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
3285                               <= sreloc->contents + sreloc->size);
3286                   if (indx == 0)
3287                     outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3288                   else
3289                     outrel.r_addend = 0;
3290                   bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3291                 }
3292
3293               sreloc = htab->srelgot;
3294
3295               outrel.r_offset = (htab->sgot->output_section->vma
3296                                  + htab->sgot->output_offset + off);
3297
3298               if (GOT_TLS_GD_P (tls_type))
3299                 dr_type = R_X86_64_DTPMOD64;
3300               else if (GOT_TLS_GDESC_P (tls_type))
3301                 goto dr_done;
3302               else
3303                 dr_type = R_X86_64_TPOFF64;
3304
3305               bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
3306               outrel.r_addend = 0;
3307               if ((dr_type == R_X86_64_TPOFF64
3308                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
3309                 outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3310               outrel.r_info = ELF64_R_INFO (indx, dr_type);
3311
3312               loc = sreloc->contents;
3313               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3314               BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
3315                           <= sreloc->contents + sreloc->size);
3316               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3317
3318               if (GOT_TLS_GD_P (tls_type))
3319                 {
3320                   if (indx == 0)
3321                     {
3322                       BFD_ASSERT (! unresolved_reloc);
3323                       bfd_put_64 (output_bfd,
3324                                   relocation - elf64_x86_64_dtpoff_base (info),
3325                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
3326                     }
3327                   else
3328                     {
3329                       bfd_put_64 (output_bfd, 0,
3330                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
3331                       outrel.r_info = ELF64_R_INFO (indx,
3332                                                     R_X86_64_DTPOFF64);
3333                       outrel.r_offset += GOT_ENTRY_SIZE;
3334                       sreloc->reloc_count++;
3335                       loc += sizeof (Elf64_External_Rela);
3336                       BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
3337                                   <= sreloc->contents + sreloc->size);
3338                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3339                     }
3340                 }
3341
3342             dr_done:
3343               if (h != NULL)
3344                 h->got.offset |= 1;
3345               else
3346                 local_got_offsets[r_symndx] |= 1;
3347             }
3348
3349           if (off >= (bfd_vma) -2
3350               && ! GOT_TLS_GDESC_P (tls_type))
3351             abort ();
3352           if (r_type == ELF64_R_TYPE (rel->r_info))
3353             {
3354               if (r_type == R_X86_64_GOTPC32_TLSDESC
3355                   || r_type == R_X86_64_TLSDESC_CALL)
3356                 relocation = htab->sgotplt->output_section->vma
3357                   + htab->sgotplt->output_offset
3358                   + offplt + htab->sgotplt_jump_table_size;
3359               else
3360                 relocation = htab->sgot->output_section->vma
3361                   + htab->sgot->output_offset + off;
3362               unresolved_reloc = FALSE;
3363             }
3364           else
3365             {
3366               bfd_vma roff = rel->r_offset;
3367
3368               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3369                 {
3370                   /* GD->IE transition.
3371                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3372                      .word 0x6666; rex64; call __tls_get_addr@plt
3373                      Change it into:
3374                      movq %fs:0, %rax
3375                      addq foo@gottpoff(%rip), %rax */
3376                   memcpy (contents + roff - 4,
3377                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3378                           16);
3379
3380                   relocation = (htab->sgot->output_section->vma
3381                                 + htab->sgot->output_offset + off
3382                                 - roff
3383                                 - input_section->output_section->vma
3384                                 - input_section->output_offset
3385                                 - 12);
3386                   bfd_put_32 (output_bfd, relocation,
3387                               contents + roff + 8);
3388                   /* Skip R_X86_64_PLT32.  */
3389                   rel++;
3390                   continue;
3391                 }
3392               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3393                 {
3394                   /* GDesc -> IE transition.
3395                      It's originally something like:
3396                      leaq x@tlsdesc(%rip), %rax
3397
3398                      Change it to:
3399                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax
3400                    */
3401
3402                   unsigned int val, type, type2;
3403
3404                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3405                   type2 = bfd_get_8 (input_bfd, contents + roff - 2);
3406                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3407
3408                   /* Now modify the instruction as appropriate. To
3409                      turn a leaq into a movq in the form we use it, it
3410                      suffices to change the second byte from 0x8d to
3411                      0x8b.  */
3412                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3413
3414                   bfd_put_32 (output_bfd,
3415                               htab->sgot->output_section->vma
3416                               + htab->sgot->output_offset + off
3417                               - rel->r_offset
3418                               - input_section->output_section->vma
3419                               - input_section->output_offset
3420                               - 4,
3421                               contents + roff);
3422                   continue;
3423                 }
3424               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3425                 {
3426                   /* GDesc -> IE transition.
3427                      It's originally:
3428                      call *(%rax)
3429
3430                      Change it to:
3431                      xchg %ax,%ax.  */
3432
3433                   unsigned int val, type;
3434
3435                   type = bfd_get_8 (input_bfd, contents + roff);
3436                   val = bfd_get_8 (input_bfd, contents + roff + 1);
3437                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3438                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3439                   continue;
3440                 }
3441               else
3442                 BFD_ASSERT (FALSE);
3443             }
3444           break;
3445
3446         case R_X86_64_TLSLD:
3447           if (! elf64_x86_64_tls_transition (info, input_bfd,
3448                                              input_section, contents,
3449                                              symtab_hdr, sym_hashes,
3450                                              &r_type, GOT_UNKNOWN,
3451                                              rel, relend, h))
3452             return FALSE;
3453
3454           if (r_type != R_X86_64_TLSLD)
3455             {
3456               /* LD->LE transition:
3457                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
3458                  We change it into:
3459                  .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
3460
3461               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3462               memcpy (contents + rel->r_offset - 3,
3463                       "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3464               /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3465               rel++;
3466               continue;
3467             }
3468
3469           if (htab->sgot == NULL)
3470             abort ();
3471
3472           off = htab->tls_ld_got.offset;
3473           if (off & 1)
3474             off &= ~1;
3475           else
3476             {
3477               Elf_Internal_Rela outrel;
3478               bfd_byte *loc;
3479
3480               if (htab->srelgot == NULL)
3481                 abort ();
3482
3483               outrel.r_offset = (htab->sgot->output_section->vma
3484                                  + htab->sgot->output_offset + off);
3485
3486               bfd_put_64 (output_bfd, 0,
3487                           htab->sgot->contents + off);
3488               bfd_put_64 (output_bfd, 0,
3489                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
3490               outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
3491               outrel.r_addend = 0;
3492               loc = htab->srelgot->contents;
3493               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3494               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3495               htab->tls_ld_got.offset |= 1;
3496             }
3497           relocation = htab->sgot->output_section->vma
3498                        + htab->sgot->output_offset + off;
3499           unresolved_reloc = FALSE;
3500           break;
3501
3502         case R_X86_64_DTPOFF32:
3503           if (info->shared || (input_section->flags & SEC_CODE) == 0)
3504             relocation -= elf64_x86_64_dtpoff_base (info);
3505           else
3506             relocation = elf64_x86_64_tpoff (info, relocation);
3507           break;
3508
3509         case R_X86_64_TPOFF32:
3510           BFD_ASSERT (! info->shared);
3511           relocation = elf64_x86_64_tpoff (info, relocation);
3512           break;
3513
3514         default:
3515           break;
3516         }
3517
3518       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3519          because such sections are not SEC_ALLOC and thus ld.so will
3520          not process them.  */
3521       if (unresolved_reloc
3522           && !((input_section->flags & SEC_DEBUGGING) != 0
3523                && h->def_dynamic))
3524         (*_bfd_error_handler)
3525           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3526            input_bfd,
3527            input_section,
3528            (long) rel->r_offset,
3529            howto->name,
3530            h->root.root.string);
3531
3532 do_relocation:
3533       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3534                                     contents, rel->r_offset,
3535                                     relocation, rel->r_addend);
3536
3537       if (r != bfd_reloc_ok)
3538         {
3539           const char *name;
3540
3541           if (h != NULL)
3542             name = h->root.root.string;
3543           else
3544             {
3545               name = bfd_elf_string_from_elf_section (input_bfd,
3546                                                       symtab_hdr->sh_link,
3547                                                       sym->st_name);
3548               if (name == NULL)
3549                 return FALSE;
3550               if (*name == '\0')
3551                 name = bfd_section_name (input_bfd, sec);
3552             }
3553
3554           if (r == bfd_reloc_overflow)
3555             {
3556               if (! ((*info->callbacks->reloc_overflow)
3557                      (info, (h ? &h->root : NULL), name, howto->name,
3558                       (bfd_vma) 0, input_bfd, input_section,
3559                       rel->r_offset)))
3560                 return FALSE;
3561             }
3562           else
3563             {
3564               (*_bfd_error_handler)
3565                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3566                  input_bfd, input_section,
3567                  (long) rel->r_offset, name, (int) r);
3568               return FALSE;
3569             }
3570         }
3571     }
3572
3573   return TRUE;
3574 }
3575
3576 /* Finish up dynamic symbol handling.  We set the contents of various
3577    dynamic sections here.  */
3578
3579 static bfd_boolean
3580 elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3581                                     struct bfd_link_info *info,
3582                                     struct elf_link_hash_entry *h,
3583                                     Elf_Internal_Sym *sym)
3584 {
3585   struct elf64_x86_64_link_hash_table *htab;
3586
3587   htab = elf64_x86_64_hash_table (info);
3588
3589   if (h->plt.offset != (bfd_vma) -1)
3590     {
3591       bfd_vma plt_index;
3592       bfd_vma got_offset;
3593       Elf_Internal_Rela rela;
3594       bfd_byte *loc;
3595       asection *plt, *gotplt, *relplt;
3596
3597       /* When building a static executable, use .iplt, .igot.plt and
3598          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
3599       if (htab->splt != 0)
3600         {
3601           plt = htab->splt;
3602           gotplt = htab->sgotplt;
3603           relplt = htab->srelplt;
3604         }
3605       else
3606         {
3607           plt = htab->iplt;
3608           gotplt = htab->igotplt;
3609           relplt = htab->irelplt;
3610         }
3611
3612       /* This symbol has an entry in the procedure linkage table.  Set
3613          it up.  */
3614       if ((h->dynindx == -1
3615            && !((h->forced_local || info->executable)
3616                 && h->def_regular
3617                 && h->type == STT_GNU_IFUNC))
3618           || plt == NULL
3619           || gotplt == NULL
3620           || relplt == NULL)
3621         abort ();
3622
3623       /* Get the index in the procedure linkage table which
3624          corresponds to this symbol.  This is the index of this symbol
3625          in all the symbols for which we are making plt entries.  The
3626          first entry in the procedure linkage table is reserved.
3627
3628          Get the offset into the .got table of the entry that
3629          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
3630          bytes. The first three are reserved for the dynamic linker.
3631
3632          For static executables, we don't reserve anything.  */
3633
3634       if (plt == htab->splt)
3635         {
3636           plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3637           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3638         }
3639       else
3640         {
3641           plt_index = h->plt.offset / PLT_ENTRY_SIZE;
3642           got_offset = plt_index * GOT_ENTRY_SIZE;
3643         }
3644
3645       /* Fill in the entry in the procedure linkage table.  */
3646       memcpy (plt->contents + h->plt.offset, elf64_x86_64_plt_entry,
3647               PLT_ENTRY_SIZE);
3648
3649       /* Insert the relocation positions of the plt section.  The magic
3650          numbers at the end of the statements are the positions of the
3651          relocations in the plt section.  */
3652       /* Put offset for jmp *name@GOTPCREL(%rip), since the
3653          instruction uses 6 bytes, subtract this value.  */
3654       bfd_put_32 (output_bfd,
3655                       (gotplt->output_section->vma
3656                        + gotplt->output_offset
3657                        + got_offset
3658                        - plt->output_section->vma
3659                        - plt->output_offset
3660                        - h->plt.offset
3661                        - 6),
3662                   plt->contents + h->plt.offset + 2);
3663
3664       /* Don't fill PLT entry for static executables.  */
3665       if (plt == htab->splt)
3666         {
3667           /* Put relocation index.  */
3668           bfd_put_32 (output_bfd, plt_index,
3669                       plt->contents + h->plt.offset + 7);
3670           /* Put offset for jmp .PLT0.  */
3671           bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3672                       plt->contents + h->plt.offset + 12);
3673         }
3674
3675       /* Fill in the entry in the global offset table, initially this
3676          points to the pushq instruction in the PLT which is at offset 6.  */
3677       bfd_put_64 (output_bfd, (plt->output_section->vma
3678                                + plt->output_offset
3679                                + h->plt.offset + 6),
3680                   gotplt->contents + got_offset);
3681
3682       /* Fill in the entry in the .rela.plt section.  */
3683       rela.r_offset = (gotplt->output_section->vma
3684                        + gotplt->output_offset
3685                        + got_offset);
3686       if (h->dynindx == -1
3687           || ((info->executable
3688                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3689               && h->def_regular
3690               && h->type == STT_GNU_IFUNC))
3691         {
3692           /* If an STT_GNU_IFUNC symbol is locally defined, generate
3693              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
3694           rela.r_info = ELF64_R_INFO (0, R_X86_64_IRELATIVE);
3695           rela.r_addend = (h->root.u.def.value
3696                            + h->root.u.def.section->output_section->vma
3697                            + h->root.u.def.section->output_offset);
3698         }
3699       else
3700         {
3701           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
3702           rela.r_addend = 0;
3703         }
3704       loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3705       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3706
3707       if (!h->def_regular)
3708         {
3709           /* Mark the symbol as undefined, rather than as defined in
3710              the .plt section.  Leave the value if there were any
3711              relocations where pointer equality matters (this is a clue
3712              for the dynamic linker, to make function pointer
3713              comparisons work between an application and shared
3714              library), otherwise set it to zero.  If a function is only
3715              called from a binary, there is no need to slow down
3716              shared libraries because of that.  */
3717           sym->st_shndx = SHN_UNDEF;
3718           if (!h->pointer_equality_needed)
3719             sym->st_value = 0;
3720         }
3721     }
3722
3723   if (h->got.offset != (bfd_vma) -1
3724       && ! GOT_TLS_GD_ANY_P (elf64_x86_64_hash_entry (h)->tls_type)
3725       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
3726     {
3727       Elf_Internal_Rela rela;
3728       bfd_byte *loc;
3729
3730       /* This symbol has an entry in the global offset table.  Set it
3731          up.  */
3732       if (htab->sgot == NULL || htab->srelgot == NULL)
3733         abort ();
3734
3735       rela.r_offset = (htab->sgot->output_section->vma
3736                        + htab->sgot->output_offset
3737                        + (h->got.offset &~ (bfd_vma) 1));
3738
3739       /* If this is a static link, or it is a -Bsymbolic link and the
3740          symbol is defined locally or was forced to be local because
3741          of a version file, we just want to emit a RELATIVE reloc.
3742          The entry in the global offset table will already have been
3743          initialized in the relocate_section function.  */
3744       if ((info->executable
3745            || info->symbolic
3746            || h->forced_local)
3747           && h->def_regular
3748           && h->pointer_equality_needed
3749           && h->type == STT_GNU_IFUNC)
3750         {
3751           /* The STT_GNU_IFUNC symbol is locally defined.  But we can't
3752              use .got.plt, which contains the real function addres,
3753              since we need pointer equality.  We load the GOT entry
3754              with the PLT entry without relocation.  */
3755           asection *plt = htab->splt ? htab->splt : htab->iplt;
3756           if (htab->sgot == NULL
3757               || h->plt.offset == (bfd_vma) -1)
3758             abort ();
3759           bfd_put_64 (output_bfd, (plt->output_section->vma
3760                                    + plt->output_offset + h->plt.offset),
3761                       htab->sgot->contents + h->got.offset);
3762           return TRUE;
3763         }
3764       else if (info->shared
3765                && SYMBOL_REFERENCES_LOCAL (info, h))
3766         {
3767           if (!h->def_regular)
3768             return FALSE;
3769           BFD_ASSERT((h->got.offset & 1) != 0);
3770           rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
3771           rela.r_addend = (h->root.u.def.value
3772                            + h->root.u.def.section->output_section->vma
3773                            + h->root.u.def.section->output_offset);
3774         }
3775       else
3776         {
3777           BFD_ASSERT((h->got.offset & 1) == 0);
3778           bfd_put_64 (output_bfd, (bfd_vma) 0,
3779                       htab->sgot->contents + h->got.offset);
3780           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
3781           rela.r_addend = 0;
3782         }
3783
3784       loc = htab->srelgot->contents;
3785       loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3786       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3787     }
3788
3789   if (h->needs_copy)
3790     {
3791       Elf_Internal_Rela rela;
3792       bfd_byte *loc;
3793
3794       /* This symbol needs a copy reloc.  Set it up.  */
3795
3796       if (h->dynindx == -1
3797           || (h->root.type != bfd_link_hash_defined
3798               && h->root.type != bfd_link_hash_defweak)
3799           || htab->srelbss == NULL)
3800         abort ();
3801
3802       rela.r_offset = (h->root.u.def.value
3803                        + h->root.u.def.section->output_section->vma
3804                        + h->root.u.def.section->output_offset);
3805       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
3806       rela.r_addend = 0;
3807       loc = htab->srelbss->contents;
3808       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3809       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3810     }
3811
3812   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3813   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3814       || h == htab->elf.hgot)
3815     sym->st_shndx = SHN_ABS;
3816
3817   return TRUE;
3818 }
3819
3820 /* Used to decide how to sort relocs in an optimal manner for the
3821    dynamic linker, before writing them out.  */
3822
3823 static enum elf_reloc_type_class
3824 elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
3825 {
3826   switch ((int) ELF64_R_TYPE (rela->r_info))
3827     {
3828     case R_X86_64_RELATIVE:
3829       return reloc_class_relative;
3830     case R_X86_64_JUMP_SLOT:
3831       return reloc_class_plt;
3832     case R_X86_64_COPY:
3833       return reloc_class_copy;
3834     default:
3835       return reloc_class_normal;
3836     }
3837 }
3838
3839 /* Finish up the dynamic sections.  */
3840
3841 static bfd_boolean
3842 elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3843 {
3844   struct elf64_x86_64_link_hash_table *htab;
3845   bfd *dynobj;
3846   asection *sdyn;
3847
3848   htab = elf64_x86_64_hash_table (info);
3849   dynobj = htab->elf.dynobj;
3850   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3851
3852   if (htab->elf.dynamic_sections_created)
3853     {
3854       Elf64_External_Dyn *dyncon, *dynconend;
3855
3856       if (sdyn == NULL || htab->sgot == NULL)
3857         abort ();
3858
3859       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3860       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3861       for (; dyncon < dynconend; dyncon++)
3862         {
3863           Elf_Internal_Dyn dyn;
3864           asection *s;
3865
3866           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3867
3868           switch (dyn.d_tag)
3869             {
3870             default:
3871               continue;
3872
3873             case DT_PLTGOT:
3874               s = htab->sgotplt;
3875               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3876               break;
3877
3878             case DT_JMPREL:
3879               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3880               break;
3881
3882             case DT_PLTRELSZ:
3883               s = htab->srelplt->output_section;
3884               dyn.d_un.d_val = s->size;
3885               break;
3886
3887             case DT_RELASZ:
3888               /* The procedure linkage table relocs (DT_JMPREL) should
3889                  not be included in the overall relocs (DT_RELA).
3890                  Therefore, we override the DT_RELASZ entry here to
3891                  make it not include the JMPREL relocs.  Since the
3892                  linker script arranges for .rela.plt to follow all
3893                  other relocation sections, we don't have to worry
3894                  about changing the DT_RELA entry.  */
3895               if (htab->srelplt != NULL)
3896                 {
3897                   s = htab->srelplt->output_section;
3898                   dyn.d_un.d_val -= s->size;
3899                 }
3900               break;
3901
3902             case DT_TLSDESC_PLT:
3903               s = htab->splt;
3904               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
3905                 + htab->tlsdesc_plt;
3906               break;
3907
3908             case DT_TLSDESC_GOT:
3909               s = htab->sgot;
3910               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
3911                 + htab->tlsdesc_got;
3912               break;
3913             }
3914
3915           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3916         }
3917
3918       /* Fill in the special first entry in the procedure linkage table.  */
3919       if (htab->splt && htab->splt->size > 0)
3920         {
3921           /* Fill in the first entry in the procedure linkage table.  */
3922           memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
3923                   PLT_ENTRY_SIZE);
3924           /* Add offset for pushq GOT+8(%rip), since the instruction
3925              uses 6 bytes subtract this value.  */
3926           bfd_put_32 (output_bfd,
3927                       (htab->sgotplt->output_section->vma
3928                        + htab->sgotplt->output_offset
3929                        + 8
3930                        - htab->splt->output_section->vma
3931                        - htab->splt->output_offset
3932                        - 6),
3933                       htab->splt->contents + 2);
3934           /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
3935              the end of the instruction.  */
3936           bfd_put_32 (output_bfd,
3937                       (htab->sgotplt->output_section->vma
3938                        + htab->sgotplt->output_offset
3939                        + 16
3940                        - htab->splt->output_section->vma
3941                        - htab->splt->output_offset
3942                        - 12),
3943                       htab->splt->contents + 8);
3944
3945           elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
3946             PLT_ENTRY_SIZE;
3947
3948           if (htab->tlsdesc_plt)
3949             {
3950               bfd_put_64 (output_bfd, (bfd_vma) 0,
3951                           htab->sgot->contents + htab->tlsdesc_got);
3952
3953               memcpy (htab->splt->contents + htab->tlsdesc_plt,
3954                       elf64_x86_64_plt0_entry,
3955                       PLT_ENTRY_SIZE);
3956
3957               /* Add offset for pushq GOT+8(%rip), since the
3958                  instruction uses 6 bytes subtract this value.  */
3959               bfd_put_32 (output_bfd,
3960                           (htab->sgotplt->output_section->vma
3961                            + htab->sgotplt->output_offset
3962                            + 8
3963                            - htab->splt->output_section->vma
3964                            - htab->splt->output_offset
3965                            - htab->tlsdesc_plt
3966                            - 6),
3967                           htab->splt->contents + htab->tlsdesc_plt + 2);
3968               /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
3969                  htab->tlsdesc_got. The 12 is the offset to the end of
3970                  the instruction.  */
3971               bfd_put_32 (output_bfd,
3972                           (htab->sgot->output_section->vma
3973                            + htab->sgot->output_offset
3974                            + htab->tlsdesc_got
3975                            - htab->splt->output_section->vma
3976                            - htab->splt->output_offset
3977                            - htab->tlsdesc_plt
3978                            - 12),
3979                           htab->splt->contents + htab->tlsdesc_plt + 8);
3980             }
3981         }
3982     }
3983
3984   if (htab->sgotplt)
3985     {
3986       /* Fill in the first three entries in the global offset table.  */
3987       if (htab->sgotplt->size > 0)
3988         {
3989           /* Set the first entry in the global offset table to the address of
3990              the dynamic section.  */
3991           if (sdyn == NULL)
3992             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
3993           else
3994             bfd_put_64 (output_bfd,
3995                         sdyn->output_section->vma + sdyn->output_offset,
3996                         htab->sgotplt->contents);
3997           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
3998           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
3999           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
4000         }
4001
4002       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
4003         GOT_ENTRY_SIZE;
4004     }
4005
4006   if (htab->sgot && htab->sgot->size > 0)
4007     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
4008       = GOT_ENTRY_SIZE;
4009
4010   return TRUE;
4011 }
4012
4013 /* Return address for Ith PLT stub in section PLT, for relocation REL
4014    or (bfd_vma) -1 if it should not be included.  */
4015
4016 static bfd_vma
4017 elf64_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4018                           const arelent *rel ATTRIBUTE_UNUSED)
4019 {
4020   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4021 }
4022
4023 /* Handle an x86-64 specific section when reading an object file.  This
4024    is called when elfcode.h finds a section with an unknown type.  */
4025
4026 static bfd_boolean
4027 elf64_x86_64_section_from_shdr (bfd *abfd,
4028                                 Elf_Internal_Shdr *hdr,
4029                                 const char *name,
4030                                 int shindex)
4031 {
4032   if (hdr->sh_type != SHT_X86_64_UNWIND)
4033     return FALSE;
4034
4035   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4036     return FALSE;
4037
4038   return TRUE;
4039 }
4040
4041 /* Hook called by the linker routine which adds symbols from an object
4042    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4043    of .bss.  */
4044
4045 static bfd_boolean
4046 elf64_x86_64_add_symbol_hook (bfd *abfd,
4047                               struct bfd_link_info *info,
4048                               Elf_Internal_Sym *sym,
4049                               const char **namep ATTRIBUTE_UNUSED,
4050                               flagword *flagsp ATTRIBUTE_UNUSED,
4051                               asection **secp,
4052                               bfd_vma *valp)
4053 {
4054   asection *lcomm;
4055
4056   switch (sym->st_shndx)
4057     {
4058     case SHN_X86_64_LCOMMON:
4059       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4060       if (lcomm == NULL)
4061         {
4062           lcomm = bfd_make_section_with_flags (abfd,
4063                                                "LARGE_COMMON",
4064                                                (SEC_ALLOC
4065                                                 | SEC_IS_COMMON
4066                                                 | SEC_LINKER_CREATED));
4067           if (lcomm == NULL)
4068             return FALSE;
4069           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4070         }
4071       *secp = lcomm;
4072       *valp = sym->st_size;
4073       break;
4074     }
4075
4076   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4077     elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4078
4079   return TRUE;
4080 }
4081
4082
4083 /* Given a BFD section, try to locate the corresponding ELF section
4084    index.  */
4085
4086 static bfd_boolean
4087 elf64_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4088                                            asection *sec, int *index)
4089 {
4090   if (sec == &_bfd_elf_large_com_section)
4091     {
4092       *index = SHN_X86_64_LCOMMON;
4093       return TRUE;
4094     }
4095   return FALSE;
4096 }
4097
4098 /* Process a symbol.  */
4099
4100 static void
4101 elf64_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4102                                 asymbol *asym)
4103 {
4104   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4105
4106   switch (elfsym->internal_elf_sym.st_shndx)
4107     {
4108     case SHN_X86_64_LCOMMON:
4109       asym->section = &_bfd_elf_large_com_section;
4110       asym->value = elfsym->internal_elf_sym.st_size;
4111       /* Common symbol doesn't set BSF_GLOBAL.  */
4112       asym->flags &= ~BSF_GLOBAL;
4113       break;
4114     }
4115 }
4116
4117 static bfd_boolean
4118 elf64_x86_64_common_definition (Elf_Internal_Sym *sym)
4119 {
4120   return (sym->st_shndx == SHN_COMMON
4121           || sym->st_shndx == SHN_X86_64_LCOMMON);
4122 }
4123
4124 static unsigned int
4125 elf64_x86_64_common_section_index (asection *sec)
4126 {
4127   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4128     return SHN_COMMON;
4129   else
4130     return SHN_X86_64_LCOMMON;
4131 }
4132
4133 static asection *
4134 elf64_x86_64_common_section (asection *sec)
4135 {
4136   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4137     return bfd_com_section_ptr;
4138   else
4139     return &_bfd_elf_large_com_section;
4140 }
4141
4142 static bfd_boolean
4143 elf64_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4144                            struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4145                            struct elf_link_hash_entry *h,
4146                            Elf_Internal_Sym *sym,
4147                            asection **psec,
4148                            bfd_vma *pvalue ATTRIBUTE_UNUSED,
4149                            unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4150                            bfd_boolean *skip ATTRIBUTE_UNUSED,
4151                            bfd_boolean *override ATTRIBUTE_UNUSED,
4152                            bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4153                            bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
4154                            bfd_boolean *newdef ATTRIBUTE_UNUSED,
4155                            bfd_boolean *newdyn,
4156                            bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4157                            bfd_boolean *newweak ATTRIBUTE_UNUSED,
4158                            bfd *abfd ATTRIBUTE_UNUSED,
4159                            asection **sec,
4160                            bfd_boolean *olddef ATTRIBUTE_UNUSED,
4161                            bfd_boolean *olddyn,
4162                            bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4163                            bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4164                            bfd *oldbfd,
4165                            asection **oldsec)
4166 {
4167   /* A normal common symbol and a large common symbol result in a
4168      normal common symbol.  We turn the large common symbol into a
4169      normal one.  */
4170   if (!*olddyn
4171       && h->root.type == bfd_link_hash_common
4172       && !*newdyn
4173       && bfd_is_com_section (*sec)
4174       && *oldsec != *sec)
4175     {
4176       if (sym->st_shndx == SHN_COMMON
4177           && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4178         {
4179           h->root.u.c.p->section
4180             = bfd_make_section_old_way (oldbfd, "COMMON");
4181           h->root.u.c.p->section->flags = SEC_ALLOC;
4182         }
4183       else if (sym->st_shndx == SHN_X86_64_LCOMMON
4184                && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
4185         *psec = *sec = bfd_com_section_ptr;
4186     }
4187
4188   return TRUE;
4189 }
4190
4191 static int
4192 elf64_x86_64_additional_program_headers (bfd *abfd,
4193                                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
4194 {
4195   asection *s;
4196   int count = 0;
4197
4198   /* Check to see if we need a large readonly segment.  */
4199   s = bfd_get_section_by_name (abfd, ".lrodata");
4200   if (s && (s->flags & SEC_LOAD))
4201     count++;
4202
4203   /* Check to see if we need a large data segment.  Since .lbss sections
4204      is placed right after the .bss section, there should be no need for
4205      a large data segment just because of .lbss.  */
4206   s = bfd_get_section_by_name (abfd, ".ldata");
4207   if (s && (s->flags & SEC_LOAD))
4208     count++;
4209
4210   return count;
4211 }
4212
4213 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
4214
4215 static bfd_boolean
4216 elf64_x86_64_hash_symbol (struct elf_link_hash_entry *h)
4217 {
4218   if (h->plt.offset != (bfd_vma) -1
4219       && !h->def_regular
4220       && !h->pointer_equality_needed)
4221     return FALSE;
4222
4223   return _bfd_elf_hash_symbol (h);
4224 }
4225
4226 static const struct bfd_elf_special_section
4227   elf64_x86_64_special_sections[]=
4228 {
4229   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4230   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4231   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4232   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4233   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4234   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4235   { NULL,                       0,          0, 0,            0 }
4236 };
4237
4238 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
4239 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
4240 #define ELF_ARCH                            bfd_arch_i386
4241 #define ELF_MACHINE_CODE                    EM_X86_64
4242 #define ELF_MAXPAGESIZE                     0x200000
4243 #define ELF_MINPAGESIZE                     0x1000
4244 #define ELF_COMMONPAGESIZE                  0x1000
4245
4246 #define elf_backend_can_gc_sections         1
4247 #define elf_backend_can_refcount            1
4248 #define elf_backend_want_got_plt            1
4249 #define elf_backend_plt_readonly            1
4250 #define elf_backend_want_plt_sym            0
4251 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
4252 #define elf_backend_rela_normal             1
4253
4254 #define elf_info_to_howto                   elf64_x86_64_info_to_howto
4255
4256 #define bfd_elf64_bfd_link_hash_table_create \
4257   elf64_x86_64_link_hash_table_create
4258 #define bfd_elf64_bfd_reloc_type_lookup     elf64_x86_64_reloc_type_lookup
4259 #define bfd_elf64_bfd_reloc_name_lookup \
4260   elf64_x86_64_reloc_name_lookup
4261
4262 #define elf_backend_adjust_dynamic_symbol   elf64_x86_64_adjust_dynamic_symbol
4263 #define elf_backend_relocs_compatible       _bfd_elf_relocs_compatible
4264 #define elf_backend_check_relocs            elf64_x86_64_check_relocs
4265 #define elf_backend_copy_indirect_symbol    elf64_x86_64_copy_indirect_symbol
4266 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
4267 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
4268 #define elf_backend_finish_dynamic_symbol   elf64_x86_64_finish_dynamic_symbol
4269 #define elf_backend_gc_mark_hook            elf64_x86_64_gc_mark_hook
4270 #define elf_backend_gc_sweep_hook           elf64_x86_64_gc_sweep_hook
4271 #define elf_backend_grok_prstatus           elf64_x86_64_grok_prstatus
4272 #define elf_backend_grok_psinfo             elf64_x86_64_grok_psinfo
4273 #define elf_backend_reloc_type_class        elf64_x86_64_reloc_type_class
4274 #define elf_backend_relocate_section        elf64_x86_64_relocate_section
4275 #define elf_backend_size_dynamic_sections   elf64_x86_64_size_dynamic_sections
4276 #define elf_backend_always_size_sections    elf64_x86_64_always_size_sections
4277 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
4278 #define elf_backend_plt_sym_val             elf64_x86_64_plt_sym_val
4279 #define elf_backend_object_p                elf64_x86_64_elf_object_p
4280 #define bfd_elf64_mkobject                  elf64_x86_64_mkobject
4281
4282 #define elf_backend_section_from_shdr \
4283         elf64_x86_64_section_from_shdr
4284
4285 #define elf_backend_section_from_bfd_section \
4286   elf64_x86_64_elf_section_from_bfd_section
4287 #define elf_backend_add_symbol_hook \
4288   elf64_x86_64_add_symbol_hook
4289 #define elf_backend_symbol_processing \
4290   elf64_x86_64_symbol_processing
4291 #define elf_backend_common_section_index \
4292   elf64_x86_64_common_section_index
4293 #define elf_backend_common_section \
4294   elf64_x86_64_common_section
4295 #define elf_backend_common_definition \
4296   elf64_x86_64_common_definition
4297 #define elf_backend_merge_symbol \
4298   elf64_x86_64_merge_symbol
4299 #define elf_backend_special_sections \
4300   elf64_x86_64_special_sections
4301 #define elf_backend_additional_program_headers \
4302   elf64_x86_64_additional_program_headers
4303 #define elf_backend_hash_symbol \
4304   elf64_x86_64_hash_symbol
4305
4306 #undef  elf_backend_post_process_headers
4307 #define elf_backend_post_process_headers  _bfd_elf_set_osabi
4308
4309 #include "elf64-target.h"
4310
4311 /* FreeBSD support.  */
4312
4313 #undef  TARGET_LITTLE_SYM
4314 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_freebsd_vec
4315 #undef  TARGET_LITTLE_NAME
4316 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
4317
4318 #undef  ELF_OSABI
4319 #define ELF_OSABI                           ELFOSABI_FREEBSD
4320
4321 #undef  elf64_bed
4322 #define elf64_bed elf64_x86_64_fbsd_bed
4323
4324 #include "elf64-target.h"