bfd/elf64-x86-64.c

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