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