bfd/elf64-x86-64.c

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