bfd/elf64-x86-64.c

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