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