1/* X86-64 specific support for ELF 2 Copyright (C) 2000-2017 Free Software Foundation, Inc. 3 Contributed by Jan Hubicka <jh@suse.cz>. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "bfd.h" 24#include "bfdlink.h" 25#include "libbfd.h" 26#include "elf-bfd.h" 27#include "elf-nacl.h" 28#include "bfd_stdint.h" 29#include "objalloc.h" 30#include "hashtab.h" 31#include "dwarf2.h" 32#include "libiberty.h" 33 34#include "opcode/i386.h" 35#include "elf/x86-64.h" 36 37#ifdef CORE_HEADER 38#include <stdarg.h> 39#include CORE_HEADER 40#endif 41 42/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 43#define MINUS_ONE (~ (bfd_vma) 0) 44 45/* Since both 32-bit and 64-bit x86-64 encode relocation type in the 46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get 47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE 48 since they are the same. */ 49 50#define ABI_64_P(abfd) \ 51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64) 52 53/* The relocation "howto" table. Order of fields: 54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow, 55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */ 56static reloc_howto_type x86_64_elf_howto_table[] = 57{ 58 HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont, 59 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000, 60 FALSE), 61 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 62 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE, 63 FALSE), 64 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 65 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff, 66 TRUE), 67 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed, 68 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff, 69 FALSE), 70 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 71 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff, 72 TRUE), 73 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 74 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff, 75 FALSE), 76 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 77 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE, 78 MINUS_ONE, FALSE), 79 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 80 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE, 81 MINUS_ONE, FALSE), 82 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 83 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE, 84 MINUS_ONE, FALSE), 85 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed, 86 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff, 87 0xffffffff, TRUE), 88 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned, 89 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff, 90 FALSE), 91 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed, 92 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff, 93 FALSE), 94 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 95 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE), 96 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield, 97 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE), 98 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 99 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE), 100 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, 101 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE), 102 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 103 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE, 104 MINUS_ONE, FALSE), 105 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 106 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE, 107 MINUS_ONE, FALSE), 108 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 109 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE, 110 MINUS_ONE, FALSE), 111 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed, 112 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff, 113 0xffffffff, TRUE), 114 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed, 115 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff, 116 0xffffffff, TRUE), 117 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed, 118 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff, 119 0xffffffff, FALSE), 120 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed, 121 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff, 122 0xffffffff, TRUE), 123 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed, 124 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff, 125 0xffffffff, FALSE), 126 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield, 127 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE, 128 TRUE), 129 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 130 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64", 131 FALSE, MINUS_ONE, MINUS_ONE, FALSE), 132 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 133 bfd_elf_generic_reloc, "R_X86_64_GOTPC32", 134 FALSE, 0xffffffff, 0xffffffff, TRUE), 135 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed, 136 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE, 137 FALSE), 138 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed, 139 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE, 140 MINUS_ONE, TRUE), 141 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed, 142 bfd_elf_generic_reloc, "R_X86_64_GOTPC64", 143 FALSE, MINUS_ONE, MINUS_ONE, TRUE), 144 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed, 145 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE, 146 MINUS_ONE, FALSE), 147 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed, 148 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE, 149 MINUS_ONE, FALSE), 150 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned, 151 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff, 152 FALSE), 153 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned, 154 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE, 155 FALSE), 156 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0, 157 complain_overflow_bitfield, bfd_elf_generic_reloc, 158 "R_X86_64_GOTPC32_TLSDESC", 159 FALSE, 0xffffffff, 0xffffffff, TRUE), 160 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0, 161 complain_overflow_dont, bfd_elf_generic_reloc, 162 "R_X86_64_TLSDESC_CALL", 163 FALSE, 0, 0, FALSE), 164 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0, 165 complain_overflow_bitfield, bfd_elf_generic_reloc, 166 "R_X86_64_TLSDESC", 167 FALSE, MINUS_ONE, MINUS_ONE, FALSE), 168 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 169 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE, 170 MINUS_ONE, FALSE), 171 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 172 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE, 173 MINUS_ONE, FALSE), 174 HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed, 175 bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff, 176 TRUE), 177 HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed, 178 bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff, 179 TRUE), 180 HOWTO(R_X86_64_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed, 181 bfd_elf_generic_reloc, "R_X86_64_GOTPCRELX", FALSE, 0xffffffff, 182 0xffffffff, TRUE), 183 HOWTO(R_X86_64_REX_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed, 184 bfd_elf_generic_reloc, "R_X86_64_REX_GOTPCRELX", FALSE, 0xffffffff, 185 0xffffffff, TRUE), 186 187 /* We have a gap in the reloc numbers here. 188 R_X86_64_standard counts the number up to this point, and 189 R_X86_64_vt_offset is the value to subtract from a reloc type of 190 R_X86_64_GNU_VT* to form an index into this table. */ 191#define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1) 192#define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard) 193 194/* GNU extension to record C++ vtable hierarchy. */ 195 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont, 196 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE), 197 198/* GNU extension to record C++ vtable member usage. */ 199 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont, 200 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0, 201 FALSE), 202 203/* Use complain_overflow_bitfield on R_X86_64_32 for x32. */ 204 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 205 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff, 206 FALSE) 207}; 208 209#define IS_X86_64_PCREL_TYPE(TYPE) \ 210 ( ((TYPE) == R_X86_64_PC8) \ 211 || ((TYPE) == R_X86_64_PC16) \ 212 || ((TYPE) == R_X86_64_PC32) \ 213 || ((TYPE) == R_X86_64_PC32_BND) \ 214 || ((TYPE) == R_X86_64_PC64)) 215 216/* Map BFD relocs to the x86_64 elf relocs. */ 217struct elf_reloc_map 218{ 219 bfd_reloc_code_real_type bfd_reloc_val; 220 unsigned char elf_reloc_val; 221}; 222 223static const struct elf_reloc_map x86_64_reloc_map[] = 224{ 225 { BFD_RELOC_NONE, R_X86_64_NONE, }, 226 { BFD_RELOC_64, R_X86_64_64, }, 227 { BFD_RELOC_32_PCREL, R_X86_64_PC32, }, 228 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,}, 229 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,}, 230 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, }, 231 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, }, 232 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, }, 233 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, }, 234 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, }, 235 { BFD_RELOC_32, R_X86_64_32, }, 236 { BFD_RELOC_X86_64_32S, R_X86_64_32S, }, 237 { BFD_RELOC_16, R_X86_64_16, }, 238 { BFD_RELOC_16_PCREL, R_X86_64_PC16, }, 239 { BFD_RELOC_8, R_X86_64_8, }, 240 { BFD_RELOC_8_PCREL, R_X86_64_PC8, }, 241 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, }, 242 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, }, 243 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, }, 244 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, }, 245 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, }, 246 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, }, 247 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, }, 248 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, }, 249 { BFD_RELOC_64_PCREL, R_X86_64_PC64, }, 250 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, }, 251 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, }, 252 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, }, 253 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, }, 254 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, }, 255 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, }, 256 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, }, 257 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, }, 258 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, }, 259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, }, 260 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, }, 261 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, }, 262 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, }, 263 { BFD_RELOC_X86_64_PC32_BND, R_X86_64_PC32_BND, }, 264 { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND, }, 265 { BFD_RELOC_X86_64_GOTPCRELX, R_X86_64_GOTPCRELX, }, 266 { BFD_RELOC_X86_64_REX_GOTPCRELX, R_X86_64_REX_GOTPCRELX, }, 267 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, }, 268 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, }, 269}; 270 271static reloc_howto_type * 272elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type) 273{ 274 unsigned i; 275 276 if (r_type == (unsigned int) R_X86_64_32) 277 { 278 if (ABI_64_P (abfd)) 279 i = r_type; 280 else 281 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1; 282 } 283 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT 284 || r_type >= (unsigned int) R_X86_64_max) 285 { 286 if (r_type >= (unsigned int) R_X86_64_standard) 287 { 288 /* xgettext:c-format */ 289 _bfd_error_handler (_("%B: invalid relocation type %d"), 290 abfd, (int) r_type); 291 r_type = R_X86_64_NONE; 292 } 293 i = r_type; 294 } 295 else 296 i = r_type - (unsigned int) R_X86_64_vt_offset; 297 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type); 298 return &x86_64_elf_howto_table[i]; 299} 300 301/* Given a BFD reloc type, return a HOWTO structure. */ 302static reloc_howto_type * 303elf_x86_64_reloc_type_lookup (bfd *abfd, 304 bfd_reloc_code_real_type code) 305{ 306 unsigned int i; 307 308 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map); 309 i++) 310 { 311 if (x86_64_reloc_map[i].bfd_reloc_val == code) 312 return elf_x86_64_rtype_to_howto (abfd, 313 x86_64_reloc_map[i].elf_reloc_val); 314 } 315 return NULL; 316} 317 318static reloc_howto_type * 319elf_x86_64_reloc_name_lookup (bfd *abfd, 320 const char *r_name) 321{ 322 unsigned int i; 323 324 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0) 325 { 326 /* Get x32 R_X86_64_32. */ 327 reloc_howto_type *reloc 328 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1]; 329 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32); 330 return reloc; 331 } 332 333 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++) 334 if (x86_64_elf_howto_table[i].name != NULL 335 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0) 336 return &x86_64_elf_howto_table[i]; 337 338 return NULL; 339} 340 341/* Given an x86_64 ELF reloc type, fill in an arelent structure. */ 342 343static void 344elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, 345 Elf_Internal_Rela *dst) 346{ 347 unsigned r_type; 348 349 r_type = ELF32_R_TYPE (dst->r_info); 350 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type); 351 BFD_ASSERT (r_type == cache_ptr->howto->type); 352} 353 354/* Support for core dump NOTE sections. */ 355static bfd_boolean 356elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 357{ 358 int offset; 359 size_t size; 360 361 switch (note->descsz) 362 { 363 default: 364 return FALSE; 365 366 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */ 367 /* pr_cursig */ 368 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 369 370 /* pr_pid */ 371 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24); 372 373 /* pr_reg */ 374 offset = 72; 375 size = 216; 376 377 break; 378 379 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */ 380 /* pr_cursig */ 381 elf_tdata (abfd)->core->signal 382 = bfd_get_16 (abfd, note->descdata + 12); 383 384 /* pr_pid */ 385 elf_tdata (abfd)->core->lwpid 386 = bfd_get_32 (abfd, note->descdata + 32); 387 388 /* pr_reg */ 389 offset = 112; 390 size = 216; 391 392 break; 393 } 394 395 /* Make a ".reg/999" section. */ 396 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 397 size, note->descpos + offset); 398} 399 400static bfd_boolean 401elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 402{ 403 switch (note->descsz) 404 { 405 default: 406 return FALSE; 407 408 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */ 409 elf_tdata (abfd)->core->pid 410 = bfd_get_32 (abfd, note->descdata + 12); 411 elf_tdata (abfd)->core->program 412 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 413 elf_tdata (abfd)->core->command 414 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 415 break; 416 417 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */ 418 elf_tdata (abfd)->core->pid 419 = bfd_get_32 (abfd, note->descdata + 24); 420 elf_tdata (abfd)->core->program 421 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 422 elf_tdata (abfd)->core->command 423 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 424 } 425 426 /* Note that for some reason, a spurious space is tacked 427 onto the end of the args in some (at least one anyway) 428 implementations, so strip it off if it exists. */ 429 430 { 431 char *command = elf_tdata (abfd)->core->command; 432 int n = strlen (command); 433 434 if (0 < n && command[n - 1] == ' ') 435 command[n - 1] = '\0'; 436 } 437 438 return TRUE; 439} 440 441#ifdef CORE_HEADER 442static char * 443elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, 444 int note_type, ...) 445{ 446 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 447 va_list ap; 448 const char *fname, *psargs; 449 long pid; 450 int cursig; 451 const void *gregs; 452 453 switch (note_type) 454 { 455 default: 456 return NULL; 457 458 case NT_PRPSINFO: 459 va_start (ap, note_type); 460 fname = va_arg (ap, const char *); 461 psargs = va_arg (ap, const char *); 462 va_end (ap); 463 464 if (bed->s->elfclass == ELFCLASS32) 465 { 466 prpsinfo32_t data; 467 memset (&data, 0, sizeof (data)); 468 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 469 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 470 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, 471 &data, sizeof (data)); 472 } 473 else 474 { 475 prpsinfo64_t data; 476 memset (&data, 0, sizeof (data)); 477 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 478 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 479 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, 480 &data, sizeof (data)); 481 } 482 /* NOTREACHED */ 483 484 case NT_PRSTATUS: 485 va_start (ap, note_type); 486 pid = va_arg (ap, long); 487 cursig = va_arg (ap, int); 488 gregs = va_arg (ap, const void *); 489 va_end (ap); 490 491 if (bed->s->elfclass == ELFCLASS32) 492 { 493 if (bed->elf_machine_code == EM_X86_64) 494 { 495 prstatusx32_t prstat; 496 memset (&prstat, 0, sizeof (prstat)); 497 prstat.pr_pid = pid; 498 prstat.pr_cursig = cursig; 499 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 500 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, 501 &prstat, sizeof (prstat)); 502 } 503 else 504 { 505 prstatus32_t prstat; 506 memset (&prstat, 0, sizeof (prstat)); 507 prstat.pr_pid = pid; 508 prstat.pr_cursig = cursig; 509 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 510 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, 511 &prstat, sizeof (prstat)); 512 } 513 } 514 else 515 { 516 prstatus64_t prstat; 517 memset (&prstat, 0, sizeof (prstat)); 518 prstat.pr_pid = pid; 519 prstat.pr_cursig = cursig; 520 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 521 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, 522 &prstat, sizeof (prstat)); 523 } 524 } 525 /* NOTREACHED */ 526} 527#endif 528 529/* Functions for the x86-64 ELF linker. */ 530 531/* The name of the dynamic interpreter. This is put in the .interp 532 section. */ 533 534#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1" 535#define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1" 536 537/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 538 copying dynamic variables from a shared lib into an app's dynbss 539 section, and instead use a dynamic relocation to point into the 540 shared lib. */ 541#define ELIMINATE_COPY_RELOCS 1 542 543/* The size in bytes of an entry in the global offset table. */ 544 545#define GOT_ENTRY_SIZE 8 546 547/* The size in bytes of an entry in the procedure linkage table. */ 548 549#define PLT_ENTRY_SIZE 16 550 551/* The first entry in a procedure linkage table looks like this. See the 552 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */ 553 554static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] = 555{ 556 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 557 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */ 558 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */ 559}; 560 561/* Subsequent entries in a procedure linkage table look like this. */ 562 563static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] = 564{ 565 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ 566 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ 567 0x68, /* pushq immediate */ 568 0, 0, 0, 0, /* replaced with index into relocation table. */ 569 0xe9, /* jmp relative */ 570 0, 0, 0, 0 /* replaced with offset to start of .plt0. */ 571}; 572 573/* The first entry in a procedure linkage table with BND relocations 574 like this. */ 575 576static const bfd_byte elf_x86_64_bnd_plt0_entry[PLT_ENTRY_SIZE] = 577{ 578 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 579 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */ 580 0x0f, 0x1f, 0 /* nopl (%rax) */ 581}; 582 583/* Subsequent entries for legacy branches in a procedure linkage table 584 with BND relocations look like this. */ 585 586static const bfd_byte elf_x86_64_legacy_plt_entry[PLT_ENTRY_SIZE] = 587{ 588 0x68, 0, 0, 0, 0, /* pushq immediate */ 589 0xe9, 0, 0, 0, 0, /* jmpq relative */ 590 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */ 591}; 592 593/* Subsequent entries for branches with BND prefx in a procedure linkage 594 table with BND relocations look like this. */ 595 596static const bfd_byte elf_x86_64_bnd_plt_entry[PLT_ENTRY_SIZE] = 597{ 598 0x68, 0, 0, 0, 0, /* pushq immediate */ 599 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */ 600 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */ 601}; 602 603/* Entries for legacy branches in the second procedure linkage table 604 look like this. */ 605 606static const bfd_byte elf_x86_64_legacy_plt2_entry[8] = 607{ 608 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ 609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ 610 0x66, 0x90 /* xchg %ax,%ax */ 611}; 612 613/* Entries for branches with BND prefix in the second procedure linkage 614 table look like this. */ 615 616static const bfd_byte elf_x86_64_bnd_plt2_entry[8] = 617{ 618 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */ 619 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ 620 0x90 /* nop */ 621}; 622 623/* .eh_frame covering the .plt section. */ 624 625static const bfd_byte elf_x86_64_eh_frame_plt[] = 626{ 627#define PLT_CIE_LENGTH 20 628#define PLT_FDE_LENGTH 36 629#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8 630#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12 631 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 632 0, 0, 0, 0, /* CIE ID */ 633 1, /* CIE version */ 634 'z', 'R', 0, /* Augmentation string */ 635 1, /* Code alignment factor */ 636 0x78, /* Data alignment factor */ 637 16, /* Return address column */ 638 1, /* Augmentation size */ 639 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */ 640 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */ 641 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */ 642 DW_CFA_nop, DW_CFA_nop, 643 644 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */ 645 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */ 646 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */ 647 0, 0, 0, 0, /* .plt size goes here */ 648 0, /* Augmentation size */ 649 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */ 650 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */ 651 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */ 652 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */ 653 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */ 654 11, /* Block length */ 655 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */ 656 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */ 657 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge, 658 DW_OP_lit3, DW_OP_shl, DW_OP_plus, 659 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop 660}; 661 662/* .eh_frame covering the BND .plt section. */ 663 664static const bfd_byte elf_x86_64_eh_frame_bnd_plt[] = 665{ 666 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 667 0, 0, 0, 0, /* CIE ID */ 668 1, /* CIE version */ 669 'z', 'R', 0, /* Augmentation string */ 670 1, /* Code alignment factor */ 671 0x78, /* Data alignment factor */ 672 16, /* Return address column */ 673 1, /* Augmentation size */ 674 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */ 675 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */ 676 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */ 677 DW_CFA_nop, DW_CFA_nop, 678 679 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */ 680 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */ 681 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */ 682 0, 0, 0, 0, /* .plt size goes here */ 683 0, /* Augmentation size */ 684 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */ 685 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */ 686 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */ 687 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */ 688 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */ 689 11, /* Block length */ 690 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */ 691 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */ 692 DW_OP_lit15, DW_OP_and, DW_OP_lit5, DW_OP_ge, 693 DW_OP_lit3, DW_OP_shl, DW_OP_plus, 694 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop 695}; 696 697/* .eh_frame covering the .plt.got section. */ 698 699static const bfd_byte elf_x86_64_eh_frame_plt_got[] = 700{ 701#define PLT_GOT_FDE_LENGTH 20 702 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 703 0, 0, 0, 0, /* CIE ID */ 704 1, /* CIE version */ 705 'z', 'R', 0, /* Augmentation string */ 706 1, /* Code alignment factor */ 707 0x78, /* Data alignment factor */ 708 16, /* Return address column */ 709 1, /* Augmentation size */ 710 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */ 711 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */ 712 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */ 713 DW_CFA_nop, DW_CFA_nop, 714 715 PLT_GOT_FDE_LENGTH, 0, 0, 0, /* FDE length */ 716 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */ 717 0, 0, 0, 0, /* the start of .plt.got goes here */ 718 0, 0, 0, 0, /* .plt.got size goes here */ 719 0, /* Augmentation size */ 720 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, 721 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop 722}; 723 724/* Architecture-specific backend data for x86-64. */ 725 726struct elf_x86_64_backend_data 727{ 728 /* Templates for the initial PLT entry and for subsequent entries. */ 729 const bfd_byte *plt0_entry; 730 const bfd_byte *plt_entry; 731 unsigned int plt_entry_size; /* Size of each PLT entry. */ 732 733 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */ 734 unsigned int plt0_got1_offset; 735 unsigned int plt0_got2_offset; 736 737 /* Offset of the end of the PC-relative instruction containing 738 plt0_got2_offset. */ 739 unsigned int plt0_got2_insn_end; 740 741 /* Offsets into plt_entry that are to be replaced with... */ 742 unsigned int plt_got_offset; /* ... address of this symbol in .got. */ 743 unsigned int plt_reloc_offset; /* ... offset into relocation table. */ 744 unsigned int plt_plt_offset; /* ... offset to start of .plt. */ 745 746 /* Length of the PC-relative instruction containing plt_got_offset. */ 747 unsigned int plt_got_insn_size; 748 749 /* Offset of the end of the PC-relative jump to plt0_entry. */ 750 unsigned int plt_plt_insn_end; 751 752 /* Offset into plt_entry where the initial value of the GOT entry points. */ 753 unsigned int plt_lazy_offset; 754 755 /* .eh_frame covering the .plt section. */ 756 const bfd_byte *eh_frame_plt; 757 unsigned int eh_frame_plt_size; 758 759 /* .eh_frame covering the .plt.got section. */ 760 const bfd_byte *eh_frame_plt_got; 761 unsigned int eh_frame_plt_got_size; 762}; 763 764#define get_elf_x86_64_arch_data(bed) \ 765 ((const struct elf_x86_64_backend_data *) (bed)->arch_data) 766 767#define get_elf_x86_64_backend_data(abfd) \ 768 get_elf_x86_64_arch_data (get_elf_backend_data (abfd)) 769 770#define GET_PLT_ENTRY_SIZE(abfd) \ 771 get_elf_x86_64_backend_data (abfd)->plt_entry_size 772 773/* These are the standard parameters. */ 774static const struct elf_x86_64_backend_data elf_x86_64_arch_bed = 775 { 776 elf_x86_64_plt0_entry, /* plt0_entry */ 777 elf_x86_64_plt_entry, /* plt_entry */ 778 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */ 779 2, /* plt0_got1_offset */ 780 8, /* plt0_got2_offset */ 781 12, /* plt0_got2_insn_end */ 782 2, /* plt_got_offset */ 783 7, /* plt_reloc_offset */ 784 12, /* plt_plt_offset */ 785 6, /* plt_got_insn_size */ 786 PLT_ENTRY_SIZE, /* plt_plt_insn_end */ 787 6, /* plt_lazy_offset */ 788 elf_x86_64_eh_frame_plt, /* eh_frame_plt */ 789 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */ 790 elf_x86_64_eh_frame_plt_got, /* eh_frame_plt_got */ 791 sizeof (elf_x86_64_eh_frame_plt_got), /* eh_frame_plt_got_size */ 792 }; 793 794static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed = 795 { 796 elf_x86_64_bnd_plt0_entry, /* plt0_entry */ 797 elf_x86_64_bnd_plt_entry, /* plt_entry */ 798 sizeof (elf_x86_64_bnd_plt_entry), /* plt_entry_size */ 799 2, /* plt0_got1_offset */ 800 1+8, /* plt0_got2_offset */ 801 1+12, /* plt0_got2_insn_end */ 802 1+2, /* plt_got_offset */ 803 1, /* plt_reloc_offset */ 804 7, /* plt_plt_offset */ 805 1+6, /* plt_got_insn_size */ 806 11, /* plt_plt_insn_end */ 807 0, /* plt_lazy_offset */ 808 elf_x86_64_eh_frame_bnd_plt, /* eh_frame_plt */ 809 sizeof (elf_x86_64_eh_frame_bnd_plt), /* eh_frame_plt_size */ 810 elf_x86_64_eh_frame_plt_got, /* eh_frame_plt_got */ 811 sizeof (elf_x86_64_eh_frame_plt_got), /* eh_frame_plt_got_size */ 812 }; 813 814#define elf_backend_arch_data &elf_x86_64_arch_bed 815 816/* Is a undefined weak symbol which is resolved to 0. Reference to an 817 undefined weak symbol is resolved to 0 when building executable if 818 it isn't dynamic and 819 1. Has non-GOT/non-PLT relocations in text section. Or 820 2. Has no GOT/PLT relocation. 821 */ 822#define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \ 823 ((EH)->elf.root.type == bfd_link_hash_undefweak \ 824 && bfd_link_executable (INFO) \ 825 && (elf_x86_64_hash_table (INFO)->interp == NULL \ 826 || !(GOT_RELOC) \ 827 || (EH)->has_non_got_reloc \ 828 || !(INFO)->dynamic_undefined_weak)) 829 830/* x86-64 ELF linker hash entry. */ 831 832struct elf_x86_64_link_hash_entry 833{ 834 struct elf_link_hash_entry elf; 835 836 /* Track dynamic relocs copied for this symbol. */ 837 struct elf_dyn_relocs *dyn_relocs; 838 839#define GOT_UNKNOWN 0 840#define GOT_NORMAL 1 841#define GOT_TLS_GD 2 842#define GOT_TLS_IE 3 843#define GOT_TLS_GDESC 4 844#define GOT_TLS_GD_BOTH_P(type) \ 845 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC)) 846#define GOT_TLS_GD_P(type) \ 847 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type)) 848#define GOT_TLS_GDESC_P(type) \ 849 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type)) 850#define GOT_TLS_GD_ANY_P(type) \ 851 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type)) 852 unsigned char tls_type; 853 854 /* TRUE if a weak symbol with a real definition needs a copy reloc. 855 When there is a weak symbol with a real definition, the processor 856 independent code will have arranged for us to see the real 857 definition first. We need to copy the needs_copy bit from the 858 real definition and check it when allowing copy reloc in PIE. */ 859 unsigned int needs_copy : 1; 860 861 /* TRUE if symbol has at least one BND relocation. */ 862 unsigned int has_bnd_reloc : 1; 863 864 /* TRUE if symbol has GOT or PLT relocations. */ 865 unsigned int has_got_reloc : 1; 866 867 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */ 868 unsigned int has_non_got_reloc : 1; 869 870 /* 0: symbol isn't __tls_get_addr. 871 1: symbol is __tls_get_addr. 872 2: symbol is unknown. */ 873 unsigned int tls_get_addr : 2; 874 875 /* Reference count of C/C++ function pointer relocations in read-write 876 section which can be resolved at run-time. */ 877 bfd_signed_vma func_pointer_refcount; 878 879 /* Information about the GOT PLT entry. Filled when there are both 880 GOT and PLT relocations against the same function. */ 881 union gotplt_union plt_got; 882 883 /* Information about the second PLT entry. Filled when has_bnd_reloc is 884 set. */ 885 union gotplt_union plt_bnd; 886 887 /* Offset of the GOTPLT entry reserved for the TLS descriptor, 888 starting at the end of the jump table. */ 889 bfd_vma tlsdesc_got; 890}; 891 892#define elf_x86_64_hash_entry(ent) \ 893 ((struct elf_x86_64_link_hash_entry *)(ent)) 894 895struct elf_x86_64_obj_tdata 896{ 897 struct elf_obj_tdata root; 898 899 /* tls_type for each local got entry. */ 900 char *local_got_tls_type; 901 902 /* GOTPLT entries for TLS descriptors. */ 903 bfd_vma *local_tlsdesc_gotent; 904}; 905 906#define elf_x86_64_tdata(abfd) \ 907 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any) 908 909#define elf_x86_64_local_got_tls_type(abfd) \ 910 (elf_x86_64_tdata (abfd)->local_got_tls_type) 911 912#define elf_x86_64_local_tlsdesc_gotent(abfd) \ 913 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent) 914 915#define is_x86_64_elf(bfd) \ 916 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 917 && elf_tdata (bfd) != NULL \ 918 && elf_object_id (bfd) == X86_64_ELF_DATA) 919 920static bfd_boolean 921elf_x86_64_mkobject (bfd *abfd) 922{ 923 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata), 924 X86_64_ELF_DATA); 925} 926 927/* x86-64 ELF linker hash table. */ 928 929struct elf_x86_64_link_hash_table 930{ 931 struct elf_link_hash_table elf; 932 933 /* Short-cuts to get to dynamic linker sections. */ 934 asection *interp; 935 asection *plt_eh_frame; 936 asection *plt_bnd; 937 asection *plt_bnd_eh_frame; 938 asection *plt_got; 939 asection *plt_got_eh_frame; 940 941 union 942 { 943 bfd_signed_vma refcount; 944 bfd_vma offset; 945 } tls_ld_got; 946 947 /* The amount of space used by the jump slots in the GOT. */ 948 bfd_vma sgotplt_jump_table_size; 949 950 /* Small local sym cache. */ 951 struct sym_cache sym_cache; 952 953 bfd_vma (*r_info) (bfd_vma, bfd_vma); 954 bfd_vma (*r_sym) (bfd_vma); 955 unsigned int pointer_r_type; 956 const char *dynamic_interpreter; 957 int dynamic_interpreter_size; 958 959 /* _TLS_MODULE_BASE_ symbol. */ 960 struct bfd_link_hash_entry *tls_module_base; 961 962 /* Used by local STT_GNU_IFUNC symbols. */ 963 htab_t loc_hash_table; 964 void * loc_hash_memory; 965 966 /* The offset into splt of the PLT entry for the TLS descriptor 967 resolver. Special values are 0, if not necessary (or not found 968 to be necessary yet), and -1 if needed but not determined 969 yet. */ 970 bfd_vma tlsdesc_plt; 971 /* The offset into sgot of the GOT entry used by the PLT entry 972 above. */ 973 bfd_vma tlsdesc_got; 974 975 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */ 976 bfd_vma next_jump_slot_index; 977 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */ 978 bfd_vma next_irelative_index; 979 980 /* TRUE if there are dynamic relocs against IFUNC symbols that apply 981 to read-only sections. */ 982 bfd_boolean readonly_dynrelocs_against_ifunc; 983}; 984 985/* Get the x86-64 ELF linker hash table from a link_info structure. */ 986 987#define elf_x86_64_hash_table(p) \ 988 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 989 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL) 990 991#define elf_x86_64_compute_jump_table_size(htab) \ 992 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE) 993 994/* Create an entry in an x86-64 ELF linker hash table. */ 995 996static struct bfd_hash_entry * 997elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry, 998 struct bfd_hash_table *table, 999 const char *string) 1000{ 1001 /* Allocate the structure if it has not already been allocated by a 1002 subclass. */ 1003 if (entry == NULL) 1004 { 1005 entry = (struct bfd_hash_entry *) 1006 bfd_hash_allocate (table, 1007 sizeof (struct elf_x86_64_link_hash_entry)); 1008 if (entry == NULL) 1009 return entry; 1010 } 1011 1012 /* Call the allocation method of the superclass. */ 1013 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 1014 if (entry != NULL) 1015 { 1016 struct elf_x86_64_link_hash_entry *eh; 1017 1018 eh = (struct elf_x86_64_link_hash_entry *) entry; 1019 eh->dyn_relocs = NULL; 1020 eh->tls_type = GOT_UNKNOWN; 1021 eh->needs_copy = 0; 1022 eh->has_bnd_reloc = 0; 1023 eh->has_got_reloc = 0; 1024 eh->has_non_got_reloc = 0; 1025 eh->tls_get_addr = 2; 1026 eh->func_pointer_refcount = 0; 1027 eh->plt_bnd.offset = (bfd_vma) -1; 1028 eh->plt_got.offset = (bfd_vma) -1; 1029 eh->tlsdesc_got = (bfd_vma) -1; 1030 } 1031 1032 return entry; 1033} 1034 1035/* Compute a hash of a local hash entry. We use elf_link_hash_entry 1036 for local symbol so that we can handle local STT_GNU_IFUNC symbols 1037 as global symbol. We reuse indx and dynstr_index for local symbol 1038 hash since they aren't used by global symbols in this backend. */ 1039 1040static hashval_t 1041elf_x86_64_local_htab_hash (const void *ptr) 1042{ 1043 struct elf_link_hash_entry *h 1044 = (struct elf_link_hash_entry *) ptr; 1045 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index); 1046} 1047 1048/* Compare local hash entries. */ 1049 1050static int 1051elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2) 1052{ 1053 struct elf_link_hash_entry *h1 1054 = (struct elf_link_hash_entry *) ptr1; 1055 struct elf_link_hash_entry *h2 1056 = (struct elf_link_hash_entry *) ptr2; 1057 1058 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index; 1059} 1060 1061/* Find and/or create a hash entry for local symbol. */ 1062 1063static struct elf_link_hash_entry * 1064elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab, 1065 bfd *abfd, const Elf_Internal_Rela *rel, 1066 bfd_boolean create) 1067{ 1068 struct elf_x86_64_link_hash_entry e, *ret; 1069 asection *sec = abfd->sections; 1070 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, 1071 htab->r_sym (rel->r_info)); 1072 void **slot; 1073 1074 e.elf.indx = sec->id; 1075 e.elf.dynstr_index = htab->r_sym (rel->r_info); 1076 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h, 1077 create ? INSERT : NO_INSERT); 1078 1079 if (!slot) 1080 return NULL; 1081 1082 if (*slot) 1083 { 1084 ret = (struct elf_x86_64_link_hash_entry *) *slot; 1085 return &ret->elf; 1086 } 1087 1088 ret = (struct elf_x86_64_link_hash_entry *) 1089 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory, 1090 sizeof (struct elf_x86_64_link_hash_entry)); 1091 if (ret) 1092 { 1093 memset (ret, 0, sizeof (*ret)); 1094 ret->elf.indx = sec->id; 1095 ret->elf.dynstr_index = htab->r_sym (rel->r_info); 1096 ret->elf.dynindx = -1; 1097 ret->func_pointer_refcount = 0; 1098 ret->plt_got.offset = (bfd_vma) -1; 1099 *slot = ret; 1100 } 1101 return &ret->elf; 1102} 1103 1104/* Destroy an X86-64 ELF linker hash table. */ 1105 1106static void 1107elf_x86_64_link_hash_table_free (bfd *obfd) 1108{ 1109 struct elf_x86_64_link_hash_table *htab 1110 = (struct elf_x86_64_link_hash_table *) obfd->link.hash; 1111 1112 if (htab->loc_hash_table) 1113 htab_delete (htab->loc_hash_table); 1114 if (htab->loc_hash_memory) 1115 objalloc_free ((struct objalloc *) htab->loc_hash_memory); 1116 _bfd_elf_link_hash_table_free (obfd); 1117} 1118 1119/* Create an X86-64 ELF linker hash table. */ 1120 1121static struct bfd_link_hash_table * 1122elf_x86_64_link_hash_table_create (bfd *abfd) 1123{ 1124 struct elf_x86_64_link_hash_table *ret; 1125 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table); 1126 1127 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt); 1128 if (ret == NULL) 1129 return NULL; 1130 1131 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 1132 elf_x86_64_link_hash_newfunc, 1133 sizeof (struct elf_x86_64_link_hash_entry), 1134 X86_64_ELF_DATA)) 1135 { 1136 free (ret); 1137 return NULL; 1138 } 1139 1140 if (ABI_64_P (abfd)) 1141 { 1142 ret->r_info = elf64_r_info; 1143 ret->r_sym = elf64_r_sym; 1144 ret->pointer_r_type = R_X86_64_64; 1145 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER; 1146 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER; 1147 } 1148 else 1149 { 1150 ret->r_info = elf32_r_info; 1151 ret->r_sym = elf32_r_sym; 1152 ret->pointer_r_type = R_X86_64_32; 1153 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; 1154 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER; 1155 } 1156 1157 ret->loc_hash_table = htab_try_create (1024, 1158 elf_x86_64_local_htab_hash, 1159 elf_x86_64_local_htab_eq, 1160 NULL); 1161 ret->loc_hash_memory = objalloc_create (); 1162 if (!ret->loc_hash_table || !ret->loc_hash_memory) 1163 { 1164 elf_x86_64_link_hash_table_free (abfd); 1165 return NULL; 1166 } 1167 ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free; 1168 1169 return &ret->elf.root; 1170} 1171 1172/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 1173 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 1174 hash table. */ 1175 1176static bfd_boolean 1177elf_x86_64_create_dynamic_sections (bfd *dynobj, 1178 struct bfd_link_info *info) 1179{ 1180 struct elf_x86_64_link_hash_table *htab; 1181 1182 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 1183 return FALSE; 1184 1185 htab = elf_x86_64_hash_table (info); 1186 if (htab == NULL) 1187 return FALSE; 1188 1189 /* Set the contents of the .interp section to the interpreter. */ 1190 if (bfd_link_executable (info) && !info->nointerp) 1191 { 1192 asection *s = bfd_get_linker_section (dynobj, ".interp"); 1193 if (s == NULL) 1194 abort (); 1195 s->size = htab->dynamic_interpreter_size; 1196 s->contents = (unsigned char *) htab->dynamic_interpreter; 1197 htab->interp = s; 1198 } 1199 1200 if (!info->no_ld_generated_unwind_info 1201 && htab->plt_eh_frame == NULL 1202 && htab->elf.splt != NULL) 1203 { 1204 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 1205 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 1206 | SEC_LINKER_CREATED); 1207 htab->plt_eh_frame 1208 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags); 1209 if (htab->plt_eh_frame == NULL 1210 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 1211 ABI_64_P (dynobj) ? 3 : 2)) 1212 return FALSE; 1213 } 1214 1215 /* Align .got section to its entry size. */ 1216 if (htab->elf.sgot != NULL 1217 && !bfd_set_section_alignment (dynobj, htab->elf.sgot, 3)) 1218 return FALSE; 1219 1220 /* Align .got.plt section to its entry size. */ 1221 if (htab->elf.sgotplt != NULL 1222 && !bfd_set_section_alignment (dynobj, htab->elf.sgotplt, 3)) 1223 return FALSE; 1224 1225 return TRUE; 1226} 1227 1228/* Copy the extra info we tack onto an elf_link_hash_entry. */ 1229 1230static void 1231elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info, 1232 struct elf_link_hash_entry *dir, 1233 struct elf_link_hash_entry *ind) 1234{ 1235 struct elf_x86_64_link_hash_entry *edir, *eind; 1236 1237 edir = (struct elf_x86_64_link_hash_entry *) dir; 1238 eind = (struct elf_x86_64_link_hash_entry *) ind; 1239 1240 edir->has_bnd_reloc |= eind->has_bnd_reloc; 1241 edir->has_got_reloc |= eind->has_got_reloc; 1242 edir->has_non_got_reloc |= eind->has_non_got_reloc; 1243 1244 if (eind->dyn_relocs != NULL) 1245 { 1246 if (edir->dyn_relocs != NULL) 1247 { 1248 struct elf_dyn_relocs **pp; 1249 struct elf_dyn_relocs *p; 1250 1251 /* Add reloc counts against the indirect sym to the direct sym 1252 list. Merge any entries against the same section. */ 1253 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 1254 { 1255 struct elf_dyn_relocs *q; 1256 1257 for (q = edir->dyn_relocs; q != NULL; q = q->next) 1258 if (q->sec == p->sec) 1259 { 1260 q->pc_count += p->pc_count; 1261 q->count += p->count; 1262 *pp = p->next; 1263 break; 1264 } 1265 if (q == NULL) 1266 pp = &p->next; 1267 } 1268 *pp = edir->dyn_relocs; 1269 } 1270 1271 edir->dyn_relocs = eind->dyn_relocs; 1272 eind->dyn_relocs = NULL; 1273 } 1274 1275 if (ind->root.type == bfd_link_hash_indirect 1276 && dir->got.refcount <= 0) 1277 { 1278 edir->tls_type = eind->tls_type; 1279 eind->tls_type = GOT_UNKNOWN; 1280 } 1281 1282 if (ELIMINATE_COPY_RELOCS 1283 && ind->root.type != bfd_link_hash_indirect 1284 && dir->dynamic_adjusted) 1285 { 1286 /* If called to transfer flags for a weakdef during processing 1287 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 1288 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 1289 if (dir->versioned != versioned_hidden) 1290 dir->ref_dynamic |= ind->ref_dynamic; 1291 dir->ref_regular |= ind->ref_regular; 1292 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 1293 dir->needs_plt |= ind->needs_plt; 1294 dir->pointer_equality_needed |= ind->pointer_equality_needed; 1295 } 1296 else 1297 { 1298 if (eind->func_pointer_refcount > 0) 1299 { 1300 edir->func_pointer_refcount += eind->func_pointer_refcount; 1301 eind->func_pointer_refcount = 0; 1302 } 1303 1304 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1305 } 1306} 1307 1308static bfd_boolean 1309elf64_x86_64_elf_object_p (bfd *abfd) 1310{ 1311 /* Set the right machine number for an x86-64 elf64 file. */ 1312 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64); 1313 return TRUE; 1314} 1315 1316static bfd_boolean 1317elf32_x86_64_elf_object_p (bfd *abfd) 1318{ 1319 /* Set the right machine number for an x86-64 elf32 file. */ 1320 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32); 1321 return TRUE; 1322} 1323 1324/* Return TRUE if the TLS access code sequence support transition 1325 from R_TYPE. */ 1326 1327static bfd_boolean 1328elf_x86_64_check_tls_transition (bfd *abfd, 1329 struct bfd_link_info *info, 1330 asection *sec, 1331 bfd_byte *contents, 1332 Elf_Internal_Shdr *symtab_hdr, 1333 struct elf_link_hash_entry **sym_hashes, 1334 unsigned int r_type, 1335 const Elf_Internal_Rela *rel, 1336 const Elf_Internal_Rela *relend) 1337{ 1338 unsigned int val; 1339 unsigned long r_symndx; 1340 bfd_boolean largepic = FALSE; 1341 struct elf_link_hash_entry *h; 1342 bfd_vma offset; 1343 struct elf_x86_64_link_hash_table *htab; 1344 bfd_byte *call; 1345 bfd_boolean indirect_call, tls_get_addr; 1346 1347 htab = elf_x86_64_hash_table (info); 1348 offset = rel->r_offset; 1349 switch (r_type) 1350 { 1351 case R_X86_64_TLSGD: 1352 case R_X86_64_TLSLD: 1353 if ((rel + 1) >= relend) 1354 return FALSE; 1355 1356 if (r_type == R_X86_64_TLSGD) 1357 { 1358 /* Check transition from GD access model. For 64bit, only 1359 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 1360 .word 0x6666; rex64; call __tls_get_addr@PLT 1361 or 1362 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 1363 .byte 0x66; rex64 1364 call *__tls_get_addr@GOTPCREL(%rip) 1365 which may be converted to 1366 addr32 call __tls_get_addr 1367 can transit to different access model. For 32bit, only 1368 leaq foo@tlsgd(%rip), %rdi 1369 .word 0x6666; rex64; call __tls_get_addr@PLT 1370 or 1371 leaq foo@tlsgd(%rip), %rdi 1372 .byte 0x66; rex64 1373 call *__tls_get_addr@GOTPCREL(%rip) 1374 which may be converted to 1375 addr32 call __tls_get_addr 1376 can transit to different access model. For largepic, 1377 we also support: 1378 leaq foo@tlsgd(%rip), %rdi 1379 movabsq $__tls_get_addr@pltoff, %rax 1380 addq $r15, %rax 1381 call *%rax 1382 or 1383 leaq foo@tlsgd(%rip), %rdi 1384 movabsq $__tls_get_addr@pltoff, %rax 1385 addq $rbx, %rax 1386 call *%rax */ 1387 1388 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d }; 1389 1390 if ((offset + 12) > sec->size) 1391 return FALSE; 1392 1393 call = contents + offset + 4; 1394 if (call[0] != 0x66 1395 || !((call[1] == 0x48 1396 && call[2] == 0xff 1397 && call[3] == 0x15) 1398 || (call[1] == 0x48 1399 && call[2] == 0x67 1400 && call[3] == 0xe8) 1401 || (call[1] == 0x66 1402 && call[2] == 0x48 1403 && call[3] == 0xe8))) 1404 { 1405 if (!ABI_64_P (abfd) 1406 || (offset + 19) > sec->size 1407 || offset < 3 1408 || memcmp (call - 7, leaq + 1, 3) != 0 1409 || memcmp (call, "\x48\xb8", 2) != 0 1410 || call[11] != 0x01 1411 || call[13] != 0xff 1412 || call[14] != 0xd0 1413 || !((call[10] == 0x48 && call[12] == 0xd8) 1414 || (call[10] == 0x4c && call[12] == 0xf8))) 1415 return FALSE; 1416 largepic = TRUE; 1417 } 1418 else if (ABI_64_P (abfd)) 1419 { 1420 if (offset < 4 1421 || memcmp (contents + offset - 4, leaq, 4) != 0) 1422 return FALSE; 1423 } 1424 else 1425 { 1426 if (offset < 3 1427 || memcmp (contents + offset - 3, leaq + 1, 3) != 0) 1428 return FALSE; 1429 } 1430 indirect_call = call[2] == 0xff; 1431 } 1432 else 1433 { 1434 /* Check transition from LD access model. Only 1435 leaq foo@tlsld(%rip), %rdi; 1436 call __tls_get_addr@PLT 1437 or 1438 leaq foo@tlsld(%rip), %rdi; 1439 call *__tls_get_addr@GOTPCREL(%rip) 1440 which may be converted to 1441 addr32 call __tls_get_addr 1442 can transit to different access model. For largepic 1443 we also support: 1444 leaq foo@tlsld(%rip), %rdi 1445 movabsq $__tls_get_addr@pltoff, %rax 1446 addq $r15, %rax 1447 call *%rax 1448 or 1449 leaq foo@tlsld(%rip), %rdi 1450 movabsq $__tls_get_addr@pltoff, %rax 1451 addq $rbx, %rax 1452 call *%rax */ 1453 1454 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d }; 1455 1456 if (offset < 3 || (offset + 9) > sec->size) 1457 return FALSE; 1458 1459 if (memcmp (contents + offset - 3, lea, 3) != 0) 1460 return FALSE; 1461 1462 call = contents + offset + 4; 1463 if (!(call[0] == 0xe8 1464 || (call[0] == 0xff && call[1] == 0x15) 1465 || (call[0] == 0x67 && call[1] == 0xe8))) 1466 { 1467 if (!ABI_64_P (abfd) 1468 || (offset + 19) > sec->size 1469 || memcmp (call, "\x48\xb8", 2) != 0 1470 || call[11] != 0x01 1471 || call[13] != 0xff 1472 || call[14] != 0xd0 1473 || !((call[10] == 0x48 && call[12] == 0xd8) 1474 || (call[10] == 0x4c && call[12] == 0xf8))) 1475 return FALSE; 1476 largepic = TRUE; 1477 } 1478 indirect_call = call[0] == 0xff; 1479 } 1480 1481 r_symndx = htab->r_sym (rel[1].r_info); 1482 if (r_symndx < symtab_hdr->sh_info) 1483 return FALSE; 1484 1485 tls_get_addr = FALSE; 1486 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1487 if (h != NULL && h->root.root.string != NULL) 1488 { 1489 struct elf_x86_64_link_hash_entry *eh 1490 = (struct elf_x86_64_link_hash_entry *) h; 1491 tls_get_addr = eh->tls_get_addr == 1; 1492 if (eh->tls_get_addr > 1) 1493 { 1494 /* Use strncmp to check __tls_get_addr since 1495 __tls_get_addr may be versioned. */ 1496 if (strncmp (h->root.root.string, "__tls_get_addr", 14) 1497 == 0) 1498 { 1499 eh->tls_get_addr = 1; 1500 tls_get_addr = TRUE; 1501 } 1502 else 1503 eh->tls_get_addr = 0; 1504 } 1505 } 1506 1507 if (!tls_get_addr) 1508 return FALSE; 1509 else if (largepic) 1510 return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64; 1511 else if (indirect_call) 1512 return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_GOTPCRELX; 1513 else 1514 return (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32 1515 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32); 1516 1517 case R_X86_64_GOTTPOFF: 1518 /* Check transition from IE access model: 1519 mov foo@gottpoff(%rip), %reg 1520 add foo@gottpoff(%rip), %reg 1521 */ 1522 1523 /* Check REX prefix first. */ 1524 if (offset >= 3 && (offset + 4) <= sec->size) 1525 { 1526 val = bfd_get_8 (abfd, contents + offset - 3); 1527 if (val != 0x48 && val != 0x4c) 1528 { 1529 /* X32 may have 0x44 REX prefix or no REX prefix. */ 1530 if (ABI_64_P (abfd)) 1531 return FALSE; 1532 } 1533 } 1534 else 1535 { 1536 /* X32 may not have any REX prefix. */ 1537 if (ABI_64_P (abfd)) 1538 return FALSE; 1539 if (offset < 2 || (offset + 3) > sec->size) 1540 return FALSE; 1541 } 1542 1543 val = bfd_get_8 (abfd, contents + offset - 2); 1544 if (val != 0x8b && val != 0x03) 1545 return FALSE; 1546 1547 val = bfd_get_8 (abfd, contents + offset - 1); 1548 return (val & 0xc7) == 5; 1549 1550 case R_X86_64_GOTPC32_TLSDESC: 1551 /* Check transition from GDesc access model: 1552 leaq x@tlsdesc(%rip), %rax 1553 1554 Make sure it's a leaq adding rip to a 32-bit offset 1555 into any register, although it's probably almost always 1556 going to be rax. */ 1557 1558 if (offset < 3 || (offset + 4) > sec->size) 1559 return FALSE; 1560 1561 val = bfd_get_8 (abfd, contents + offset - 3); 1562 if ((val & 0xfb) != 0x48) 1563 return FALSE; 1564 1565 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d) 1566 return FALSE; 1567 1568 val = bfd_get_8 (abfd, contents + offset - 1); 1569 return (val & 0xc7) == 0x05; 1570 1571 case R_X86_64_TLSDESC_CALL: 1572 /* Check transition from GDesc access model: 1573 call *x@tlsdesc(%rax) 1574 */ 1575 if (offset + 2 <= sec->size) 1576 { 1577 /* Make sure that it's a call *x@tlsdesc(%rax). */ 1578 call = contents + offset; 1579 return call[0] == 0xff && call[1] == 0x10; 1580 } 1581 1582 return FALSE; 1583 1584 default: 1585 abort (); 1586 } 1587} 1588 1589/* Return TRUE if the TLS access transition is OK or no transition 1590 will be performed. Update R_TYPE if there is a transition. */ 1591 1592static bfd_boolean 1593elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, 1594 asection *sec, bfd_byte *contents, 1595 Elf_Internal_Shdr *symtab_hdr, 1596 struct elf_link_hash_entry **sym_hashes, 1597 unsigned int *r_type, int tls_type, 1598 const Elf_Internal_Rela *rel, 1599 const Elf_Internal_Rela *relend, 1600 struct elf_link_hash_entry *h, 1601 unsigned long r_symndx, 1602 bfd_boolean from_relocate_section) 1603{ 1604 unsigned int from_type = *r_type; 1605 unsigned int to_type = from_type; 1606 bfd_boolean check = TRUE; 1607 1608 /* Skip TLS transition for functions. */ 1609 if (h != NULL 1610 && (h->type == STT_FUNC 1611 || h->type == STT_GNU_IFUNC)) 1612 return TRUE; 1613 1614 switch (from_type) 1615 { 1616 case R_X86_64_TLSGD: 1617 case R_X86_64_GOTPC32_TLSDESC: 1618 case R_X86_64_TLSDESC_CALL: 1619 case R_X86_64_GOTTPOFF: 1620 if (bfd_link_executable (info)) 1621 { 1622 if (h == NULL) 1623 to_type = R_X86_64_TPOFF32; 1624 else 1625 to_type = R_X86_64_GOTTPOFF; 1626 } 1627 1628 /* When we are called from elf_x86_64_relocate_section, there may 1629 be additional transitions based on TLS_TYPE. */ 1630 if (from_relocate_section) 1631 { 1632 unsigned int new_to_type = to_type; 1633 1634 if (bfd_link_executable (info) 1635 && h != NULL 1636 && h->dynindx == -1 1637 && tls_type == GOT_TLS_IE) 1638 new_to_type = R_X86_64_TPOFF32; 1639 1640 if (to_type == R_X86_64_TLSGD 1641 || to_type == R_X86_64_GOTPC32_TLSDESC 1642 || to_type == R_X86_64_TLSDESC_CALL) 1643 { 1644 if (tls_type == GOT_TLS_IE) 1645 new_to_type = R_X86_64_GOTTPOFF; 1646 } 1647 1648 /* We checked the transition before when we were called from 1649 elf_x86_64_check_relocs. We only want to check the new 1650 transition which hasn't been checked before. */ 1651 check = new_to_type != to_type && from_type == to_type; 1652 to_type = new_to_type; 1653 } 1654 1655 break; 1656 1657 case R_X86_64_TLSLD: 1658 if (bfd_link_executable (info)) 1659 to_type = R_X86_64_TPOFF32; 1660 break; 1661 1662 default: 1663 return TRUE; 1664 } 1665 1666 /* Return TRUE if there is no transition. */ 1667 if (from_type == to_type) 1668 return TRUE; 1669 1670 /* Check if the transition can be performed. */ 1671 if (check 1672 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents, 1673 symtab_hdr, sym_hashes, 1674 from_type, rel, relend)) 1675 { 1676 reloc_howto_type *from, *to; 1677 const char *name; 1678 1679 from = elf_x86_64_rtype_to_howto (abfd, from_type); 1680 to = elf_x86_64_rtype_to_howto (abfd, to_type); 1681 1682 if (h) 1683 name = h->root.root.string; 1684 else 1685 { 1686 struct elf_x86_64_link_hash_table *htab; 1687 1688 htab = elf_x86_64_hash_table (info); 1689 if (htab == NULL) 1690 name = "*unknown*"; 1691 else 1692 { 1693 Elf_Internal_Sym *isym; 1694 1695 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 1696 abfd, r_symndx); 1697 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); 1698 } 1699 } 1700 1701 _bfd_error_handler 1702 /* xgettext:c-format */ 1703 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx " 1704 "in section `%A' failed"), 1705 abfd, sec, from->name, to->name, name, 1706 (unsigned long) rel->r_offset); 1707 bfd_set_error (bfd_error_bad_value); 1708 return FALSE; 1709 } 1710 1711 *r_type = to_type; 1712 return TRUE; 1713} 1714 1715/* Rename some of the generic section flags to better document how they 1716 are used here. */ 1717#define need_convert_load sec_flg0 1718#define check_relocs_failed sec_flg1 1719 1720static bfd_boolean 1721elf_x86_64_need_pic (bfd *input_bfd, asection *sec, 1722 struct elf_link_hash_entry *h, 1723 Elf_Internal_Shdr *symtab_hdr, 1724 Elf_Internal_Sym *isym, 1725 reloc_howto_type *howto) 1726{ 1727 const char *v = ""; 1728 const char *und = ""; 1729 const char *pic = ""; 1730 1731 const char *name; 1732 if (h) 1733 { 1734 name = h->root.root.string; 1735 switch (ELF_ST_VISIBILITY (h->other)) 1736 { 1737 case STV_HIDDEN: 1738 v = _("hidden symbol "); 1739 break; 1740 case STV_INTERNAL: 1741 v = _("internal symbol "); 1742 break; 1743 case STV_PROTECTED: 1744 v = _("protected symbol "); 1745 break; 1746 default: 1747 v = _("symbol "); 1748 pic = _("; recompile with -fPIC"); 1749 break; 1750 } 1751 1752 if (!h->def_regular && !h->def_dynamic) 1753 und = _("undefined "); 1754 } 1755 else 1756 { 1757 name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL); 1758 pic = _("; recompile with -fPIC"); 1759 } 1760 1761 /* xgettext:c-format */ 1762 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can " 1763 "not be used when making a shared object%s"), 1764 input_bfd, howto->name, und, v, name, pic); 1765 bfd_set_error (bfd_error_bad_value); 1766 sec->check_relocs_failed = 1; 1767 return FALSE; 1768} 1769 1770/* With the local symbol, foo, we convert 1771 mov foo@GOTPCREL(%rip), %reg 1772 to 1773 lea foo(%rip), %reg 1774 and convert 1775 call/jmp *foo@GOTPCREL(%rip) 1776 to 1777 nop call foo/jmp foo nop 1778 When PIC is false, convert 1779 test %reg, foo@GOTPCREL(%rip) 1780 to 1781 test $foo, %reg 1782 and convert 1783 binop foo@GOTPCREL(%rip), %reg 1784 to 1785 binop $foo, %reg 1786 where binop is one of adc, add, and, cmp, or, sbb, sub, xor 1787 instructions. */ 1788 1789static bfd_boolean 1790elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, 1791 bfd_byte *contents, 1792 Elf_Internal_Rela *irel, 1793 struct elf_link_hash_entry *h, 1794 bfd_boolean *converted, 1795 struct bfd_link_info *link_info) 1796{ 1797 struct elf_x86_64_link_hash_table *htab; 1798 bfd_boolean is_pic; 1799 bfd_boolean require_reloc_pc32; 1800 bfd_boolean relocx; 1801 bfd_boolean to_reloc_pc32; 1802 asection *tsec; 1803 char symtype; 1804 bfd_signed_vma raddend; 1805 unsigned int opcode; 1806 unsigned int modrm; 1807 unsigned int r_type = ELF32_R_TYPE (irel->r_info); 1808 unsigned int r_symndx; 1809 bfd_vma toff; 1810 bfd_vma roff = irel->r_offset; 1811 1812 if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2)) 1813 return TRUE; 1814 1815 raddend = irel->r_addend; 1816 /* Addend for 32-bit PC-relative relocation must be -4. */ 1817 if (raddend != -4) 1818 return TRUE; 1819 1820 htab = elf_x86_64_hash_table (link_info); 1821 is_pic = bfd_link_pic (link_info); 1822 1823 relocx = (r_type == R_X86_64_GOTPCRELX 1824 || r_type == R_X86_64_REX_GOTPCRELX); 1825 1826 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for 1827 --no-relax. */ 1828 require_reloc_pc32 1829 = link_info->disable_target_specific_optimizations > 1; 1830 1831 r_symndx = htab->r_sym (irel->r_info); 1832 1833 opcode = bfd_get_8 (abfd, contents + roff - 2); 1834 1835 /* Convert mov to lea since it has been done for a while. */ 1836 if (opcode != 0x8b) 1837 { 1838 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX 1839 for call, jmp or one of adc, add, and, cmp, or, sbb, sub, 1840 test, xor instructions. */ 1841 if (!relocx) 1842 return TRUE; 1843 } 1844 1845 /* We convert only to R_X86_64_PC32: 1846 1. Branch. 1847 2. R_X86_64_GOTPCREL since we can't modify REX byte. 1848 3. require_reloc_pc32 is true. 1849 4. PIC. 1850 */ 1851 to_reloc_pc32 = (opcode == 0xff 1852 || !relocx 1853 || require_reloc_pc32 1854 || is_pic); 1855 1856 /* Get the symbol referred to by the reloc. */ 1857 if (h == NULL) 1858 { 1859 Elf_Internal_Sym *isym 1860 = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx); 1861 1862 /* Skip relocation against undefined symbols. */ 1863 if (isym->st_shndx == SHN_UNDEF) 1864 return TRUE; 1865 1866 symtype = ELF_ST_TYPE (isym->st_info); 1867 1868 if (isym->st_shndx == SHN_ABS) 1869 tsec = bfd_abs_section_ptr; 1870 else if (isym->st_shndx == SHN_COMMON) 1871 tsec = bfd_com_section_ptr; 1872 else if (isym->st_shndx == SHN_X86_64_LCOMMON) 1873 tsec = &_bfd_elf_large_com_section; 1874 else 1875 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 1876 1877 toff = isym->st_value; 1878 } 1879 else 1880 { 1881 /* Undefined weak symbol is only bound locally in executable 1882 and its reference is resolved as 0 without relocation 1883 overflow. We can only perform this optimization for 1884 GOTPCRELX relocations since we need to modify REX byte. 1885 It is OK convert mov with R_X86_64_GOTPCREL to 1886 R_X86_64_PC32. */ 1887 if ((relocx || opcode == 0x8b) 1888 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, 1889 TRUE, 1890 elf_x86_64_hash_entry (h))) 1891 { 1892 if (opcode == 0xff) 1893 { 1894 /* Skip for branch instructions since R_X86_64_PC32 1895 may overflow. */ 1896 if (require_reloc_pc32) 1897 return TRUE; 1898 } 1899 else if (relocx) 1900 { 1901 /* For non-branch instructions, we can convert to 1902 R_X86_64_32/R_X86_64_32S since we know if there 1903 is a REX byte. */ 1904 to_reloc_pc32 = FALSE; 1905 } 1906 1907 /* Since we don't know the current PC when PIC is true, 1908 we can't convert to R_X86_64_PC32. */ 1909 if (to_reloc_pc32 && is_pic) 1910 return TRUE; 1911 1912 goto convert; 1913 } 1914 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since 1915 ld.so may use its link-time address. */ 1916 else if ((h->def_regular 1917 || h->root.type == bfd_link_hash_defined 1918 || h->root.type == bfd_link_hash_defweak) 1919 && h != htab->elf.hdynamic 1920 && SYMBOL_REFERENCES_LOCAL (link_info, h)) 1921 { 1922 /* bfd_link_hash_new or bfd_link_hash_undefined is 1923 set by an assignment in a linker script in 1924 bfd_elf_record_link_assignment. */ 1925 if (h->def_regular 1926 && (h->root.type == bfd_link_hash_new 1927 || h->root.type == bfd_link_hash_undefined 1928 || ((h->root.type == bfd_link_hash_defined 1929 || h->root.type == bfd_link_hash_defweak) 1930 && h->root.u.def.section == bfd_und_section_ptr))) 1931 { 1932 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */ 1933 if (require_reloc_pc32) 1934 return TRUE; 1935 goto convert; 1936 } 1937 tsec = h->root.u.def.section; 1938 toff = h->root.u.def.value; 1939 symtype = h->type; 1940 } 1941 else 1942 return TRUE; 1943 } 1944 1945 /* Don't convert GOTPCREL relocation against large section. */ 1946 if (elf_section_data (tsec) != NULL 1947 && (elf_section_flags (tsec) & SHF_X86_64_LARGE) != 0) 1948 return TRUE; 1949 1950 /* We can only estimate relocation overflow for R_X86_64_PC32. */ 1951 if (!to_reloc_pc32) 1952 goto convert; 1953 1954 if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE) 1955 { 1956 /* At this stage in linking, no SEC_MERGE symbol has been 1957 adjusted, so all references to such symbols need to be 1958 passed through _bfd_merged_section_offset. (Later, in 1959 relocate_section, all SEC_MERGE symbols *except* for 1960 section symbols have been adjusted.) 1961 1962 gas may reduce relocations against symbols in SEC_MERGE 1963 sections to a relocation against the section symbol when 1964 the original addend was zero. When the reloc is against 1965 a section symbol we should include the addend in the 1966 offset passed to _bfd_merged_section_offset, since the 1967 location of interest is the original symbol. On the 1968 other hand, an access to "sym+addend" where "sym" is not 1969 a section symbol should not include the addend; Such an 1970 access is presumed to be an offset from "sym"; The 1971 location of interest is just "sym". */ 1972 if (symtype == STT_SECTION) 1973 toff += raddend; 1974 1975 toff = _bfd_merged_section_offset (abfd, &tsec, 1976 elf_section_data (tsec)->sec_info, 1977 toff); 1978 1979 if (symtype != STT_SECTION) 1980 toff += raddend; 1981 } 1982 else 1983 toff += raddend; 1984 1985 /* Don't convert if R_X86_64_PC32 relocation overflows. */ 1986 if (tsec->output_section == sec->output_section) 1987 { 1988 if ((toff - roff + 0x80000000) > 0xffffffff) 1989 return TRUE; 1990 } 1991 else 1992 { 1993 bfd_signed_vma distance; 1994 1995 /* At this point, we don't know the load addresses of TSEC 1996 section nor SEC section. We estimate the distrance between 1997 SEC and TSEC. We store the estimated distances in the 1998 compressed_size field of the output section, which is only 1999 used to decompress the compressed input section. */ 2000 if (sec->output_section->compressed_size == 0) 2001 { 2002 asection *asect; 2003 bfd_size_type size = 0; 2004 for (asect = link_info->output_bfd->sections; 2005 asect != NULL; 2006 asect = asect->next) 2007 /* Skip debug sections since compressed_size is used to 2008 compress debug sections. */ 2009 if ((asect->flags & SEC_DEBUGGING) == 0) 2010 { 2011 asection *i; 2012 for (i = asect->map_head.s; 2013 i != NULL; 2014 i = i->map_head.s) 2015 { 2016 size = align_power (size, i->alignment_power); 2017 size += i->size; 2018 } 2019 asect->compressed_size = size; 2020 } 2021 } 2022 2023 /* Don't convert GOTPCREL relocations if TSEC isn't placed 2024 after SEC. */ 2025 distance = (tsec->output_section->compressed_size 2026 - sec->output_section->compressed_size); 2027 if (distance < 0) 2028 return TRUE; 2029 2030 /* Take PT_GNU_RELRO segment into account by adding 2031 maxpagesize. */ 2032 if ((toff + distance + get_elf_backend_data (abfd)->maxpagesize 2033 - roff + 0x80000000) > 0xffffffff) 2034 return TRUE; 2035 } 2036 2037convert: 2038 if (opcode == 0xff) 2039 { 2040 /* We have "call/jmp *foo@GOTPCREL(%rip)". */ 2041 unsigned int nop; 2042 unsigned int disp; 2043 bfd_vma nop_offset; 2044 2045 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to 2046 R_X86_64_PC32. */ 2047 modrm = bfd_get_8 (abfd, contents + roff - 1); 2048 if (modrm == 0x25) 2049 { 2050 /* Convert to "jmp foo nop". */ 2051 modrm = 0xe9; 2052 nop = NOP_OPCODE; 2053 nop_offset = irel->r_offset + 3; 2054 disp = bfd_get_32 (abfd, contents + irel->r_offset); 2055 irel->r_offset -= 1; 2056 bfd_put_32 (abfd, disp, contents + irel->r_offset); 2057 } 2058 else 2059 { 2060 struct elf_x86_64_link_hash_entry *eh 2061 = (struct elf_x86_64_link_hash_entry *) h; 2062 2063 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE 2064 is a nop prefix. */ 2065 modrm = 0xe8; 2066 /* To support TLS optimization, always use addr32 prefix for 2067 "call *__tls_get_addr@GOTPCREL(%rip)". */ 2068 if (eh && eh->tls_get_addr == 1) 2069 { 2070 nop = 0x67; 2071 nop_offset = irel->r_offset - 2; 2072 } 2073 else 2074 { 2075 nop = link_info->call_nop_byte; 2076 if (link_info->call_nop_as_suffix) 2077 { 2078 nop_offset = irel->r_offset + 3; 2079 disp = bfd_get_32 (abfd, contents + irel->r_offset); 2080 irel->r_offset -= 1; 2081 bfd_put_32 (abfd, disp, contents + irel->r_offset); 2082 } 2083 else 2084 nop_offset = irel->r_offset - 2; 2085 } 2086 } 2087 bfd_put_8 (abfd, nop, contents + nop_offset); 2088 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1); 2089 r_type = R_X86_64_PC32; 2090 } 2091 else 2092 { 2093 unsigned int rex; 2094 unsigned int rex_mask = REX_R; 2095 2096 if (r_type == R_X86_64_REX_GOTPCRELX) 2097 rex = bfd_get_8 (abfd, contents + roff - 3); 2098 else 2099 rex = 0; 2100 2101 if (opcode == 0x8b) 2102 { 2103 if (to_reloc_pc32) 2104 { 2105 /* Convert "mov foo@GOTPCREL(%rip), %reg" to 2106 "lea foo(%rip), %reg". */ 2107 opcode = 0x8d; 2108 r_type = R_X86_64_PC32; 2109 } 2110 else 2111 { 2112 /* Convert "mov foo@GOTPCREL(%rip), %reg" to 2113 "mov $foo, %reg". */ 2114 opcode = 0xc7; 2115 modrm = bfd_get_8 (abfd, contents + roff - 1); 2116 modrm = 0xc0 | (modrm & 0x38) >> 3; 2117 if ((rex & REX_W) != 0 2118 && ABI_64_P (link_info->output_bfd)) 2119 { 2120 /* Keep the REX_W bit in REX byte for LP64. */ 2121 r_type = R_X86_64_32S; 2122 goto rewrite_modrm_rex; 2123 } 2124 else 2125 { 2126 /* If the REX_W bit in REX byte isn't needed, 2127 use R_X86_64_32 and clear the W bit to avoid 2128 sign-extend imm32 to imm64. */ 2129 r_type = R_X86_64_32; 2130 /* Clear the W bit in REX byte. */ 2131 rex_mask |= REX_W; 2132 goto rewrite_modrm_rex; 2133 } 2134 } 2135 } 2136 else 2137 { 2138 /* R_X86_64_PC32 isn't supported. */ 2139 if (to_reloc_pc32) 2140 return TRUE; 2141 2142 modrm = bfd_get_8 (abfd, contents + roff - 1); 2143 if (opcode == 0x85) 2144 { 2145 /* Convert "test %reg, foo@GOTPCREL(%rip)" to 2146 "test $foo, %reg". */ 2147 modrm = 0xc0 | (modrm & 0x38) >> 3; 2148 opcode = 0xf7; 2149 } 2150 else 2151 { 2152 /* Convert "binop foo@GOTPCREL(%rip), %reg" to 2153 "binop $foo, %reg". */ 2154 modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c); 2155 opcode = 0x81; 2156 } 2157 2158 /* Use R_X86_64_32 with 32-bit operand to avoid relocation 2159 overflow when sign-extending imm32 to imm64. */ 2160 r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32; 2161 2162rewrite_modrm_rex: 2163 bfd_put_8 (abfd, modrm, contents + roff - 1); 2164 2165 if (rex) 2166 { 2167 /* Move the R bit to the B bit in REX byte. */ 2168 rex = (rex & ~rex_mask) | (rex & REX_R) >> 2; 2169 bfd_put_8 (abfd, rex, contents + roff - 3); 2170 } 2171 2172 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */ 2173 irel->r_addend = 0; 2174 } 2175 2176 bfd_put_8 (abfd, opcode, contents + roff - 2); 2177 } 2178 2179 irel->r_info = htab->r_info (r_symndx, r_type); 2180 2181 *converted = TRUE; 2182 2183 return TRUE; 2184} 2185 2186/* Look through the relocs for a section during the first phase, and 2187 calculate needed space in the global offset table, procedure 2188 linkage table, and dynamic reloc sections. */ 2189 2190static bfd_boolean 2191elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, 2192 asection *sec, 2193 const Elf_Internal_Rela *relocs) 2194{ 2195 struct elf_x86_64_link_hash_table *htab; 2196 Elf_Internal_Shdr *symtab_hdr; 2197 struct elf_link_hash_entry **sym_hashes; 2198 const Elf_Internal_Rela *rel; 2199 const Elf_Internal_Rela *rel_end; 2200 asection *sreloc; 2201 bfd_byte *contents; 2202 bfd_boolean use_plt_got; 2203 2204 if (bfd_link_relocatable (info)) 2205 return TRUE; 2206 2207 /* Don't do anything special with non-loaded, non-alloced sections. 2208 In particular, any relocs in such sections should not affect GOT 2209 and PLT reference counting (ie. we don't allow them to create GOT 2210 or PLT entries), there's no possibility or desire to optimize TLS 2211 relocs, and there's not much point in propagating relocs to shared 2212 libs that the dynamic linker won't relocate. */ 2213 if ((sec->flags & SEC_ALLOC) == 0) 2214 return TRUE; 2215 2216 BFD_ASSERT (is_x86_64_elf (abfd)); 2217 2218 htab = elf_x86_64_hash_table (info); 2219 if (htab == NULL) 2220 { 2221 sec->check_relocs_failed = 1; 2222 return FALSE; 2223 } 2224 2225 /* Get the section contents. */ 2226 if (elf_section_data (sec)->this_hdr.contents != NULL) 2227 contents = elf_section_data (sec)->this_hdr.contents; 2228 else if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 2229 { 2230 sec->check_relocs_failed = 1; 2231 return FALSE; 2232 } 2233 2234 use_plt_got = get_elf_x86_64_backend_data (abfd) == &elf_x86_64_arch_bed; 2235 2236 symtab_hdr = &elf_symtab_hdr (abfd); 2237 sym_hashes = elf_sym_hashes (abfd); 2238 2239 sreloc = NULL; 2240 2241 rel_end = relocs + sec->reloc_count; 2242 for (rel = relocs; rel < rel_end; rel++) 2243 { 2244 unsigned int r_type; 2245 unsigned long r_symndx; 2246 struct elf_link_hash_entry *h; 2247 struct elf_x86_64_link_hash_entry *eh; 2248 Elf_Internal_Sym *isym; 2249 const char *name; 2250 bfd_boolean size_reloc; 2251 2252 r_symndx = htab->r_sym (rel->r_info); 2253 r_type = ELF32_R_TYPE (rel->r_info); 2254 2255 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 2256 { 2257 /* xgettext:c-format */ 2258 _bfd_error_handler (_("%B: bad symbol index: %d"), 2259 abfd, r_symndx); 2260 goto error_return; 2261 } 2262 2263 if (r_symndx < symtab_hdr->sh_info) 2264 { 2265 /* A local symbol. */ 2266 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 2267 abfd, r_symndx); 2268 if (isym == NULL) 2269 goto error_return; 2270 2271 /* Check relocation against local STT_GNU_IFUNC symbol. */ 2272 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 2273 { 2274 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, 2275 TRUE); 2276 if (h == NULL) 2277 goto error_return; 2278 2279 /* Fake a STT_GNU_IFUNC symbol. */ 2280 h->type = STT_GNU_IFUNC; 2281 h->def_regular = 1; 2282 h->ref_regular = 1; 2283 h->forced_local = 1; 2284 h->root.type = bfd_link_hash_defined; 2285 } 2286 else 2287 h = NULL; 2288 } 2289 else 2290 { 2291 isym = NULL; 2292 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2293 while (h->root.type == bfd_link_hash_indirect 2294 || h->root.type == bfd_link_hash_warning) 2295 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2296 } 2297 2298 /* Check invalid x32 relocations. */ 2299 if (!ABI_64_P (abfd)) 2300 switch (r_type) 2301 { 2302 default: 2303 break; 2304 2305 case R_X86_64_DTPOFF64: 2306 case R_X86_64_TPOFF64: 2307 case R_X86_64_PC64: 2308 case R_X86_64_GOTOFF64: 2309 case R_X86_64_GOT64: 2310 case R_X86_64_GOTPCREL64: 2311 case R_X86_64_GOTPC64: 2312 case R_X86_64_GOTPLT64: 2313 case R_X86_64_PLTOFF64: 2314 { 2315 if (h) 2316 name = h->root.root.string; 2317 else 2318 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, 2319 NULL); 2320 _bfd_error_handler 2321 /* xgettext:c-format */ 2322 (_("%B: relocation %s against symbol `%s' isn't " 2323 "supported in x32 mode"), abfd, 2324 x86_64_elf_howto_table[r_type].name, name); 2325 bfd_set_error (bfd_error_bad_value); 2326 goto error_return; 2327 } 2328 break; 2329 } 2330 2331 if (h != NULL) 2332 { 2333 switch (r_type) 2334 { 2335 default: 2336 break; 2337 2338 case R_X86_64_PC32_BND: 2339 case R_X86_64_PLT32_BND: 2340 case R_X86_64_PC32: 2341 case R_X86_64_PLT32: 2342 case R_X86_64_32: 2343 case R_X86_64_64: 2344 /* MPX PLT is supported only if elf_x86_64_arch_bed 2345 is used in 64-bit mode. */ 2346 if (ABI_64_P (abfd) 2347 && info->bndplt 2348 && (get_elf_x86_64_backend_data (abfd) 2349 == &elf_x86_64_arch_bed)) 2350 { 2351 elf_x86_64_hash_entry (h)->has_bnd_reloc = 1; 2352 2353 /* Create the second PLT for Intel MPX support. */ 2354 if (htab->plt_bnd == NULL) 2355 { 2356 const struct elf_backend_data *bed; 2357 2358 bed = get_elf_backend_data (info->output_bfd); 2359 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry) == 8 2360 && (sizeof (elf_x86_64_bnd_plt2_entry) 2361 == sizeof (elf_x86_64_legacy_plt2_entry))); 2362 2363 if (htab->elf.dynobj == NULL) 2364 htab->elf.dynobj = abfd; 2365 htab->plt_bnd 2366 = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2367 ".plt.bnd", 2368 (bed->dynamic_sec_flags 2369 | SEC_ALLOC 2370 | SEC_CODE 2371 | SEC_LOAD 2372 | SEC_READONLY)); 2373 if (htab->plt_bnd == NULL 2374 || !bfd_set_section_alignment (htab->elf.dynobj, 2375 htab->plt_bnd, 2376 3)) 2377 goto error_return; 2378 } 2379 2380 if (!info->no_ld_generated_unwind_info 2381 && htab->plt_bnd_eh_frame == NULL) 2382 { 2383 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 2384 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2385 | SEC_LINKER_CREATED); 2386 htab->plt_bnd_eh_frame 2387 = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2388 ".eh_frame", 2389 flags); 2390 if (htab->plt_bnd_eh_frame == NULL 2391 || !bfd_set_section_alignment (htab->elf.dynobj, 2392 htab->plt_bnd_eh_frame, 2393 3)) 2394 goto error_return; 2395 } 2396 } 2397 /* Fall through. */ 2398 2399 case R_X86_64_32S: 2400 case R_X86_64_PC64: 2401 case R_X86_64_GOTPCREL: 2402 case R_X86_64_GOTPCRELX: 2403 case R_X86_64_REX_GOTPCRELX: 2404 case R_X86_64_GOTPCREL64: 2405 if (htab->elf.dynobj == NULL) 2406 htab->elf.dynobj = abfd; 2407 /* Create the ifunc sections for static executables. */ 2408 if (h->type == STT_GNU_IFUNC 2409 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj, 2410 info)) 2411 goto error_return; 2412 break; 2413 } 2414 2415 /* It is referenced by a non-shared object. */ 2416 h->ref_regular = 1; 2417 h->root.non_ir_ref = 1; 2418 2419 if (h->type == STT_GNU_IFUNC) 2420 elf_tdata (info->output_bfd)->has_gnu_symbols 2421 |= elf_gnu_symbol_ifunc; 2422 } 2423 2424 if (! elf_x86_64_tls_transition (info, abfd, sec, contents, 2425 symtab_hdr, sym_hashes, 2426 &r_type, GOT_UNKNOWN, 2427 rel, rel_end, h, r_symndx, FALSE)) 2428 goto error_return; 2429 2430 eh = (struct elf_x86_64_link_hash_entry *) h; 2431 switch (r_type) 2432 { 2433 case R_X86_64_TLSLD: 2434 htab->tls_ld_got.refcount += 1; 2435 goto create_got; 2436 2437 case R_X86_64_TPOFF32: 2438 if (!bfd_link_executable (info) && ABI_64_P (abfd)) 2439 return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym, 2440 &x86_64_elf_howto_table[r_type]); 2441 if (eh != NULL) 2442 eh->has_got_reloc = 1; 2443 break; 2444 2445 case R_X86_64_GOTTPOFF: 2446 if (!bfd_link_executable (info)) 2447 info->flags |= DF_STATIC_TLS; 2448 /* Fall through */ 2449 2450 case R_X86_64_GOT32: 2451 case R_X86_64_GOTPCREL: 2452 case R_X86_64_GOTPCRELX: 2453 case R_X86_64_REX_GOTPCRELX: 2454 case R_X86_64_TLSGD: 2455 case R_X86_64_GOT64: 2456 case R_X86_64_GOTPCREL64: 2457 case R_X86_64_GOTPLT64: 2458 case R_X86_64_GOTPC32_TLSDESC: 2459 case R_X86_64_TLSDESC_CALL: 2460 /* This symbol requires a global offset table entry. */ 2461 { 2462 int tls_type, old_tls_type; 2463 2464 switch (r_type) 2465 { 2466 default: tls_type = GOT_NORMAL; break; 2467 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break; 2468 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break; 2469 case R_X86_64_GOTPC32_TLSDESC: 2470 case R_X86_64_TLSDESC_CALL: 2471 tls_type = GOT_TLS_GDESC; break; 2472 } 2473 2474 if (h != NULL) 2475 { 2476 h->got.refcount += 1; 2477 old_tls_type = eh->tls_type; 2478 } 2479 else 2480 { 2481 bfd_signed_vma *local_got_refcounts; 2482 2483 /* This is a global offset table entry for a local symbol. */ 2484 local_got_refcounts = elf_local_got_refcounts (abfd); 2485 if (local_got_refcounts == NULL) 2486 { 2487 bfd_size_type size; 2488 2489 size = symtab_hdr->sh_info; 2490 size *= sizeof (bfd_signed_vma) 2491 + sizeof (bfd_vma) + sizeof (char); 2492 local_got_refcounts = ((bfd_signed_vma *) 2493 bfd_zalloc (abfd, size)); 2494 if (local_got_refcounts == NULL) 2495 goto error_return; 2496 elf_local_got_refcounts (abfd) = local_got_refcounts; 2497 elf_x86_64_local_tlsdesc_gotent (abfd) 2498 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info); 2499 elf_x86_64_local_got_tls_type (abfd) 2500 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info); 2501 } 2502 local_got_refcounts[r_symndx] += 1; 2503 old_tls_type 2504 = elf_x86_64_local_got_tls_type (abfd) [r_symndx]; 2505 } 2506 2507 /* If a TLS symbol is accessed using IE at least once, 2508 there is no point to use dynamic model for it. */ 2509 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN 2510 && (! GOT_TLS_GD_ANY_P (old_tls_type) 2511 || tls_type != GOT_TLS_IE)) 2512 { 2513 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type)) 2514 tls_type = old_tls_type; 2515 else if (GOT_TLS_GD_ANY_P (old_tls_type) 2516 && GOT_TLS_GD_ANY_P (tls_type)) 2517 tls_type |= old_tls_type; 2518 else 2519 { 2520 if (h) 2521 name = h->root.root.string; 2522 else 2523 name = bfd_elf_sym_name (abfd, symtab_hdr, 2524 isym, NULL); 2525 _bfd_error_handler 2526 /* xgettext:c-format */ 2527 (_("%B: '%s' accessed both as normal and thread local symbol"), 2528 abfd, name); 2529 bfd_set_error (bfd_error_bad_value); 2530 goto error_return; 2531 } 2532 } 2533 2534 if (old_tls_type != tls_type) 2535 { 2536 if (eh != NULL) 2537 eh->tls_type = tls_type; 2538 else 2539 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type; 2540 } 2541 } 2542 /* Fall through */ 2543 2544 case R_X86_64_GOTOFF64: 2545 case R_X86_64_GOTPC32: 2546 case R_X86_64_GOTPC64: 2547 create_got: 2548 if (eh != NULL) 2549 eh->has_got_reloc = 1; 2550 if (htab->elf.sgot == NULL) 2551 { 2552 if (htab->elf.dynobj == NULL) 2553 htab->elf.dynobj = abfd; 2554 if (!_bfd_elf_create_got_section (htab->elf.dynobj, 2555 info)) 2556 goto error_return; 2557 } 2558 break; 2559 2560 case R_X86_64_PLT32: 2561 case R_X86_64_PLT32_BND: 2562 /* This symbol requires a procedure linkage table entry. We 2563 actually build the entry in adjust_dynamic_symbol, 2564 because this might be a case of linking PIC code which is 2565 never referenced by a dynamic object, in which case we 2566 don't need to generate a procedure linkage table entry 2567 after all. */ 2568 2569 /* If this is a local symbol, we resolve it directly without 2570 creating a procedure linkage table entry. */ 2571 if (h == NULL) 2572 continue; 2573 2574 eh->has_got_reloc = 1; 2575 h->needs_plt = 1; 2576 h->plt.refcount += 1; 2577 break; 2578 2579 case R_X86_64_PLTOFF64: 2580 /* This tries to form the 'address' of a function relative 2581 to GOT. For global symbols we need a PLT entry. */ 2582 if (h != NULL) 2583 { 2584 h->needs_plt = 1; 2585 h->plt.refcount += 1; 2586 } 2587 goto create_got; 2588 2589 case R_X86_64_SIZE32: 2590 case R_X86_64_SIZE64: 2591 size_reloc = TRUE; 2592 goto do_size; 2593 2594 case R_X86_64_32: 2595 if (!ABI_64_P (abfd)) 2596 goto pointer; 2597 /* Fall through. */ 2598 case R_X86_64_8: 2599 case R_X86_64_16: 2600 case R_X86_64_32S: 2601 /* Check relocation overflow as these relocs may lead to 2602 run-time relocation overflow. Don't error out for 2603 sections we don't care about, such as debug sections or 2604 when relocation overflow check is disabled. */ 2605 if (!info->no_reloc_overflow_check 2606 && (bfd_link_pic (info) 2607 || (bfd_link_executable (info) 2608 && h != NULL 2609 && !h->def_regular 2610 && h->def_dynamic 2611 && (sec->flags & SEC_READONLY) == 0))) 2612 return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym, 2613 &x86_64_elf_howto_table[r_type]); 2614 /* Fall through. */ 2615 2616 case R_X86_64_PC8: 2617 case R_X86_64_PC16: 2618 case R_X86_64_PC32: 2619 case R_X86_64_PC32_BND: 2620 case R_X86_64_PC64: 2621 case R_X86_64_64: 2622pointer: 2623 if (eh != NULL && (sec->flags & SEC_CODE) != 0) 2624 eh->has_non_got_reloc = 1; 2625 /* We are called after all symbols have been resolved. Only 2626 relocation against STT_GNU_IFUNC symbol must go through 2627 PLT. */ 2628 if (h != NULL 2629 && (bfd_link_executable (info) 2630 || h->type == STT_GNU_IFUNC)) 2631 { 2632 /* If this reloc is in a read-only section, we might 2633 need a copy reloc. We can't check reliably at this 2634 stage whether the section is read-only, as input 2635 sections have not yet been mapped to output sections. 2636 Tentatively set the flag for now, and correct in 2637 adjust_dynamic_symbol. */ 2638 h->non_got_ref = 1; 2639 2640 /* We may need a .plt entry if the symbol is a function 2641 defined in a shared lib or is a STT_GNU_IFUNC function 2642 referenced from the code or read-only section. */ 2643 if (!h->def_regular 2644 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0) 2645 h->plt.refcount += 1; 2646 2647 if (r_type == R_X86_64_PC32) 2648 { 2649 /* Since something like ".long foo - ." may be used 2650 as pointer, make sure that PLT is used if foo is 2651 a function defined in a shared library. */ 2652 if ((sec->flags & SEC_CODE) == 0) 2653 h->pointer_equality_needed = 1; 2654 } 2655 else if (r_type != R_X86_64_PC32_BND 2656 && r_type != R_X86_64_PC64) 2657 { 2658 h->pointer_equality_needed = 1; 2659 /* At run-time, R_X86_64_64 can be resolved for both 2660 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S 2661 can only be resolved for x32. */ 2662 if ((sec->flags & SEC_READONLY) == 0 2663 && (r_type == R_X86_64_64 2664 || (!ABI_64_P (abfd) 2665 && (r_type == R_X86_64_32 2666 || r_type == R_X86_64_32S)))) 2667 eh->func_pointer_refcount += 1; 2668 } 2669 } 2670 2671 size_reloc = FALSE; 2672do_size: 2673 /* If we are creating a shared library, and this is a reloc 2674 against a global symbol, or a non PC relative reloc 2675 against a local symbol, then we need to copy the reloc 2676 into the shared library. However, if we are linking with 2677 -Bsymbolic, we do not need to copy a reloc against a 2678 global symbol which is defined in an object we are 2679 including in the link (i.e., DEF_REGULAR is set). At 2680 this point we have not seen all the input files, so it is 2681 possible that DEF_REGULAR is not set now but will be set 2682 later (it is never cleared). In case of a weak definition, 2683 DEF_REGULAR may be cleared later by a strong definition in 2684 a shared library. We account for that possibility below by 2685 storing information in the relocs_copied field of the hash 2686 table entry. A similar situation occurs when creating 2687 shared libraries and symbol visibility changes render the 2688 symbol local. 2689 2690 If on the other hand, we are creating an executable, we 2691 may need to keep relocations for symbols satisfied by a 2692 dynamic library if we manage to avoid copy relocs for the 2693 symbol. 2694 2695 Generate dynamic pointer relocation against STT_GNU_IFUNC 2696 symbol in the non-code section. */ 2697 if ((bfd_link_pic (info) 2698 && (! IS_X86_64_PCREL_TYPE (r_type) 2699 || (h != NULL 2700 && (! (bfd_link_pie (info) 2701 || SYMBOLIC_BIND (info, h)) 2702 || h->root.type == bfd_link_hash_defweak 2703 || !h->def_regular)))) 2704 || (h != NULL 2705 && h->type == STT_GNU_IFUNC 2706 && r_type == htab->pointer_r_type 2707 && (sec->flags & SEC_CODE) == 0) 2708 || (ELIMINATE_COPY_RELOCS 2709 && !bfd_link_pic (info) 2710 && h != NULL 2711 && (h->root.type == bfd_link_hash_defweak 2712 || !h->def_regular))) 2713 { 2714 struct elf_dyn_relocs *p; 2715 struct elf_dyn_relocs **head; 2716 2717 /* We must copy these reloc types into the output file. 2718 Create a reloc section in dynobj and make room for 2719 this reloc. */ 2720 if (sreloc == NULL) 2721 { 2722 if (htab->elf.dynobj == NULL) 2723 htab->elf.dynobj = abfd; 2724 2725 sreloc = _bfd_elf_make_dynamic_reloc_section 2726 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2, 2727 abfd, /*rela?*/ TRUE); 2728 2729 if (sreloc == NULL) 2730 goto error_return; 2731 } 2732 2733 /* If this is a global symbol, we count the number of 2734 relocations we need for this symbol. */ 2735 if (h != NULL) 2736 head = &eh->dyn_relocs; 2737 else 2738 { 2739 /* Track dynamic relocs needed for local syms too. 2740 We really need local syms available to do this 2741 easily. Oh well. */ 2742 asection *s; 2743 void **vpp; 2744 2745 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 2746 abfd, r_symndx); 2747 if (isym == NULL) 2748 goto error_return; 2749 2750 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 2751 if (s == NULL) 2752 s = sec; 2753 2754 /* Beware of type punned pointers vs strict aliasing 2755 rules. */ 2756 vpp = &(elf_section_data (s)->local_dynrel); 2757 head = (struct elf_dyn_relocs **)vpp; 2758 } 2759 2760 p = *head; 2761 if (p == NULL || p->sec != sec) 2762 { 2763 bfd_size_type amt = sizeof *p; 2764 2765 p = ((struct elf_dyn_relocs *) 2766 bfd_alloc (htab->elf.dynobj, amt)); 2767 if (p == NULL) 2768 goto error_return; 2769 p->next = *head; 2770 *head = p; 2771 p->sec = sec; 2772 p->count = 0; 2773 p->pc_count = 0; 2774 } 2775 2776 p->count += 1; 2777 /* Count size relocation as PC-relative relocation. */ 2778 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc) 2779 p->pc_count += 1; 2780 } 2781 break; 2782 2783 /* This relocation describes the C++ object vtable hierarchy. 2784 Reconstruct it for later use during GC. */ 2785 case R_X86_64_GNU_VTINHERIT: 2786 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2787 goto error_return; 2788 break; 2789 2790 /* This relocation describes which C++ vtable entries are actually 2791 used. Record for later use during GC. */ 2792 case R_X86_64_GNU_VTENTRY: 2793 BFD_ASSERT (h != NULL); 2794 if (h != NULL 2795 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 2796 goto error_return; 2797 break; 2798 2799 default: 2800 break; 2801 } 2802 2803 if (use_plt_got 2804 && h != NULL 2805 && h->plt.refcount > 0 2806 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed) 2807 || h->got.refcount > 0) 2808 && htab->plt_got == NULL) 2809 { 2810 /* Create the GOT procedure linkage table. */ 2811 unsigned int plt_got_align; 2812 const struct elf_backend_data *bed; 2813 2814 bed = get_elf_backend_data (info->output_bfd); 2815 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry) == 8 2816 && (sizeof (elf_x86_64_bnd_plt2_entry) 2817 == sizeof (elf_x86_64_legacy_plt2_entry))); 2818 plt_got_align = 3; 2819 2820 if (htab->elf.dynobj == NULL) 2821 htab->elf.dynobj = abfd; 2822 htab->plt_got 2823 = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2824 ".plt.got", 2825 (bed->dynamic_sec_flags 2826 | SEC_ALLOC 2827 | SEC_CODE 2828 | SEC_LOAD 2829 | SEC_READONLY)); 2830 if (htab->plt_got == NULL 2831 || !bfd_set_section_alignment (htab->elf.dynobj, 2832 htab->plt_got, 2833 plt_got_align)) 2834 goto error_return; 2835 2836 if (!info->no_ld_generated_unwind_info 2837 && htab->plt_got_eh_frame == NULL 2838 && get_elf_x86_64_backend_data (abfd)->eh_frame_plt_got != NULL) 2839 { 2840 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 2841 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2842 | SEC_LINKER_CREATED); 2843 htab->plt_got_eh_frame 2844 = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2845 ".eh_frame", 2846 flags); 2847 if (htab->plt_got_eh_frame == NULL 2848 || !bfd_set_section_alignment (htab->elf.dynobj, 2849 htab->plt_got_eh_frame, 2850 ABI_64_P (htab->elf.dynobj) ? 3 : 2)) 2851 goto error_return; 2852 } 2853 } 2854 2855 if ((r_type == R_X86_64_GOTPCREL 2856 || r_type == R_X86_64_GOTPCRELX 2857 || r_type == R_X86_64_REX_GOTPCRELX) 2858 && (h == NULL || h->type != STT_GNU_IFUNC)) 2859 sec->need_convert_load = 1; 2860 } 2861 2862 if (elf_section_data (sec)->this_hdr.contents != contents) 2863 { 2864 if (!info->keep_memory) 2865 free (contents); 2866 else 2867 { 2868 /* Cache the section contents for elf_link_input_bfd. */ 2869 elf_section_data (sec)->this_hdr.contents = contents; 2870 } 2871 } 2872 2873 return TRUE; 2874 2875error_return: 2876 if (elf_section_data (sec)->this_hdr.contents != contents) 2877 free (contents); 2878 sec->check_relocs_failed = 1; 2879 return FALSE; 2880} 2881 2882/* Return the section that should be marked against GC for a given 2883 relocation. */ 2884 2885static asection * 2886elf_x86_64_gc_mark_hook (asection *sec, 2887 struct bfd_link_info *info, 2888 Elf_Internal_Rela *rel, 2889 struct elf_link_hash_entry *h, 2890 Elf_Internal_Sym *sym) 2891{ 2892 if (h != NULL) 2893 switch (ELF32_R_TYPE (rel->r_info)) 2894 { 2895 case R_X86_64_GNU_VTINHERIT: 2896 case R_X86_64_GNU_VTENTRY: 2897 return NULL; 2898 } 2899 2900 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2901} 2902 2903/* Remove undefined weak symbol from the dynamic symbol table if it 2904 is resolved to 0. */ 2905 2906static bfd_boolean 2907elf_x86_64_fixup_symbol (struct bfd_link_info *info, 2908 struct elf_link_hash_entry *h) 2909{ 2910 if (h->dynindx != -1 2911 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, 2912 elf_x86_64_hash_entry (h)->has_got_reloc, 2913 elf_x86_64_hash_entry (h))) 2914 { 2915 h->dynindx = -1; 2916 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 2917 h->dynstr_index); 2918 } 2919 return TRUE; 2920} 2921 2922/* Adjust a symbol defined by a dynamic object and referenced by a 2923 regular object. The current definition is in some section of the 2924 dynamic object, but we're not including those sections. We have to 2925 change the definition to something the rest of the link can 2926 understand. */ 2927 2928static bfd_boolean 2929elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info, 2930 struct elf_link_hash_entry *h) 2931{ 2932 struct elf_x86_64_link_hash_table *htab; 2933 asection *s, *srel; 2934 struct elf_x86_64_link_hash_entry *eh; 2935 struct elf_dyn_relocs *p; 2936 2937 /* STT_GNU_IFUNC symbol must go through PLT. */ 2938 if (h->type == STT_GNU_IFUNC) 2939 { 2940 /* All local STT_GNU_IFUNC references must be treate as local 2941 calls via local PLT. */ 2942 if (h->ref_regular 2943 && SYMBOL_CALLS_LOCAL (info, h)) 2944 { 2945 bfd_size_type pc_count = 0, count = 0; 2946 struct elf_dyn_relocs **pp; 2947 2948 eh = (struct elf_x86_64_link_hash_entry *) h; 2949 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 2950 { 2951 pc_count += p->pc_count; 2952 p->count -= p->pc_count; 2953 p->pc_count = 0; 2954 count += p->count; 2955 if (p->count == 0) 2956 *pp = p->next; 2957 else 2958 pp = &p->next; 2959 } 2960 2961 if (pc_count || count) 2962 { 2963 h->non_got_ref = 1; 2964 if (pc_count) 2965 { 2966 /* Increment PLT reference count only for PC-relative 2967 references. */ 2968 h->needs_plt = 1; 2969 if (h->plt.refcount <= 0) 2970 h->plt.refcount = 1; 2971 else 2972 h->plt.refcount += 1; 2973 } 2974 } 2975 } 2976 2977 if (h->plt.refcount <= 0) 2978 { 2979 h->plt.offset = (bfd_vma) -1; 2980 h->needs_plt = 0; 2981 } 2982 return TRUE; 2983 } 2984 2985 /* If this is a function, put it in the procedure linkage table. We 2986 will fill in the contents of the procedure linkage table later, 2987 when we know the address of the .got section. */ 2988 if (h->type == STT_FUNC 2989 || h->needs_plt) 2990 { 2991 if (h->plt.refcount <= 0 2992 || SYMBOL_CALLS_LOCAL (info, h) 2993 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2994 && h->root.type == bfd_link_hash_undefweak)) 2995 { 2996 /* This case can occur if we saw a PLT32 reloc in an input 2997 file, but the symbol was never referred to by a dynamic 2998 object, or if all references were garbage collected. In 2999 such a case, we don't actually need to build a procedure 3000 linkage table, and we can just do a PC32 reloc instead. */ 3001 h->plt.offset = (bfd_vma) -1; 3002 h->needs_plt = 0; 3003 } 3004 3005 return TRUE; 3006 } 3007 else 3008 /* It's possible that we incorrectly decided a .plt reloc was 3009 needed for an R_X86_64_PC32 reloc to a non-function sym in 3010 check_relocs. We can't decide accurately between function and 3011 non-function syms in check-relocs; Objects loaded later in 3012 the link may change h->type. So fix it now. */ 3013 h->plt.offset = (bfd_vma) -1; 3014 3015 /* If this is a weak symbol, and there is a real definition, the 3016 processor independent code will have arranged for us to see the 3017 real definition first, and we can just use the same value. */ 3018 if (h->u.weakdef != NULL) 3019 { 3020 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3021 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3022 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3023 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3024 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc) 3025 { 3026 eh = (struct elf_x86_64_link_hash_entry *) h; 3027 h->non_got_ref = h->u.weakdef->non_got_ref; 3028 eh->needs_copy = h->u.weakdef->needs_copy; 3029 } 3030 return TRUE; 3031 } 3032 3033 /* This is a reference to a symbol defined by a dynamic object which 3034 is not a function. */ 3035 3036 /* If we are creating a shared library, we must presume that the 3037 only references to the symbol are via the global offset table. 3038 For such cases we need not do anything here; the relocations will 3039 be handled correctly by relocate_section. */ 3040 if (!bfd_link_executable (info)) 3041 return TRUE; 3042 3043 /* If there are no references to this symbol that do not use the 3044 GOT, we don't need to generate a copy reloc. */ 3045 if (!h->non_got_ref) 3046 return TRUE; 3047 3048 /* If -z nocopyreloc was given, we won't generate them either. */ 3049 if (info->nocopyreloc) 3050 { 3051 h->non_got_ref = 0; 3052 return TRUE; 3053 } 3054 3055 if (ELIMINATE_COPY_RELOCS) 3056 { 3057 eh = (struct elf_x86_64_link_hash_entry *) h; 3058 for (p = eh->dyn_relocs; p != NULL; p = p->next) 3059 { 3060 s = p->sec->output_section; 3061 if (s != NULL && (s->flags & SEC_READONLY) != 0) 3062 break; 3063 } 3064 3065 /* If we didn't find any dynamic relocs in read-only sections, then 3066 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 3067 if (p == NULL) 3068 { 3069 h->non_got_ref = 0; 3070 return TRUE; 3071 } 3072 } 3073 3074 /* We must allocate the symbol in our .dynbss section, which will 3075 become part of the .bss section of the executable. There will be 3076 an entry for this symbol in the .dynsym section. The dynamic 3077 object will contain position independent code, so all references 3078 from the dynamic object to this symbol will go through the global 3079 offset table. The dynamic linker will use the .dynsym entry to 3080 determine the address it must put in the global offset table, so 3081 both the dynamic object and the regular object will refer to the 3082 same memory location for the variable. */ 3083 3084 htab = elf_x86_64_hash_table (info); 3085 if (htab == NULL) 3086 return FALSE; 3087 3088 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker 3089 to copy the initial value out of the dynamic object and into the 3090 runtime process image. */ 3091 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 3092 { 3093 s = htab->elf.sdynrelro; 3094 srel = htab->elf.sreldynrelro; 3095 } 3096 else 3097 { 3098 s = htab->elf.sdynbss; 3099 srel = htab->elf.srelbss; 3100 } 3101 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 3102 { 3103 const struct elf_backend_data *bed; 3104 bed = get_elf_backend_data (info->output_bfd); 3105 srel->size += bed->s->sizeof_rela; 3106 h->needs_copy = 1; 3107 } 3108 3109 return _bfd_elf_adjust_dynamic_copy (info, h, s); 3110} 3111 3112/* Allocate space in .plt, .got and associated reloc sections for 3113 dynamic relocs. */ 3114 3115static bfd_boolean 3116elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 3117{ 3118 struct bfd_link_info *info; 3119 struct elf_x86_64_link_hash_table *htab; 3120 struct elf_x86_64_link_hash_entry *eh; 3121 struct elf_dyn_relocs *p; 3122 const struct elf_backend_data *bed; 3123 unsigned int plt_entry_size; 3124 bfd_boolean resolved_to_zero; 3125 3126 if (h->root.type == bfd_link_hash_indirect) 3127 return TRUE; 3128 3129 eh = (struct elf_x86_64_link_hash_entry *) h; 3130 3131 info = (struct bfd_link_info *) inf; 3132 htab = elf_x86_64_hash_table (info); 3133 if (htab == NULL) 3134 return FALSE; 3135 bed = get_elf_backend_data (info->output_bfd); 3136 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd); 3137 3138 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, 3139 eh->has_got_reloc, 3140 eh); 3141 3142 /* We can't use the GOT PLT if pointer equality is needed since 3143 finish_dynamic_symbol won't clear symbol value and the dynamic 3144 linker won't update the GOT slot. We will get into an infinite 3145 loop at run-time. */ 3146 if (htab->plt_got != NULL 3147 && h->type != STT_GNU_IFUNC 3148 && !h->pointer_equality_needed 3149 && h->plt.refcount > 0 3150 && h->got.refcount > 0) 3151 { 3152 /* Don't use the regular PLT if there are both GOT and GOTPLT 3153 reloctions. */ 3154 h->plt.offset = (bfd_vma) -1; 3155 3156 /* Use the GOT PLT. */ 3157 eh->plt_got.refcount = 1; 3158 } 3159 3160 /* Clear the reference count of function pointer relocations if 3161 symbol isn't a normal function. */ 3162 if (h->type != STT_FUNC) 3163 eh->func_pointer_refcount = 0; 3164 3165 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it 3166 here if it is defined and referenced in a non-shared object. */ 3167 if (h->type == STT_GNU_IFUNC 3168 && h->def_regular) 3169 { 3170 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, 3171 &eh->dyn_relocs, 3172 &htab->readonly_dynrelocs_against_ifunc, 3173 plt_entry_size, 3174 plt_entry_size, 3175 GOT_ENTRY_SIZE, TRUE)) 3176 { 3177 asection *s = htab->plt_bnd; 3178 if (h->plt.offset != (bfd_vma) -1 && s != NULL) 3179 { 3180 /* Use the .plt.bnd section if it is created. */ 3181 eh->plt_bnd.offset = s->size; 3182 3183 /* Make room for this entry in the .plt.bnd section. */ 3184 s->size += sizeof (elf_x86_64_legacy_plt2_entry); 3185 } 3186 3187 return TRUE; 3188 } 3189 else 3190 return FALSE; 3191 } 3192 /* Don't create the PLT entry if there are only function pointer 3193 relocations which can be resolved at run-time. */ 3194 else if (htab->elf.dynamic_sections_created 3195 && (h->plt.refcount > eh->func_pointer_refcount 3196 || eh->plt_got.refcount > 0)) 3197 { 3198 bfd_boolean use_plt_got; 3199 3200 /* Clear the reference count of function pointer relocations 3201 if PLT is used. */ 3202 eh->func_pointer_refcount = 0; 3203 3204 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed) 3205 { 3206 /* Don't use the regular PLT for DF_BIND_NOW. */ 3207 h->plt.offset = (bfd_vma) -1; 3208 3209 /* Use the GOT PLT. */ 3210 h->got.refcount = 1; 3211 eh->plt_got.refcount = 1; 3212 } 3213 3214 use_plt_got = eh->plt_got.refcount > 0; 3215 3216 /* Make sure this symbol is output as a dynamic symbol. 3217 Undefined weak syms won't yet be marked as dynamic. */ 3218 if (h->dynindx == -1 3219 && !h->forced_local 3220 && !resolved_to_zero) 3221 { 3222 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3223 return FALSE; 3224 } 3225 3226 if (bfd_link_pic (info) 3227 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 3228 { 3229 asection *s = htab->elf.splt; 3230 asection *bnd_s = htab->plt_bnd; 3231 asection *got_s = htab->plt_got; 3232 3233 /* If this is the first .plt entry, make room for the special 3234 first entry. The .plt section is used by prelink to undo 3235 prelinking for dynamic relocations. */ 3236 if (s->size == 0) 3237 s->size = plt_entry_size; 3238 3239 if (use_plt_got) 3240 eh->plt_got.offset = got_s->size; 3241 else 3242 { 3243 h->plt.offset = s->size; 3244 if (bnd_s) 3245 eh->plt_bnd.offset = bnd_s->size; 3246 } 3247 3248 /* If this symbol is not defined in a regular file, and we are 3249 not generating a shared library, then set the symbol to this 3250 location in the .plt. This is required to make function 3251 pointers compare as equal between the normal executable and 3252 the shared library. */ 3253 if (! bfd_link_pic (info) 3254 && !h->def_regular) 3255 { 3256 if (use_plt_got) 3257 { 3258 /* We need to make a call to the entry of the GOT PLT 3259 instead of regular PLT entry. */ 3260 h->root.u.def.section = got_s; 3261 h->root.u.def.value = eh->plt_got.offset; 3262 } 3263 else 3264 { 3265 if (bnd_s) 3266 { 3267 /* We need to make a call to the entry of the second 3268 PLT instead of regular PLT entry. */ 3269 h->root.u.def.section = bnd_s; 3270 h->root.u.def.value = eh->plt_bnd.offset; 3271 } 3272 else 3273 { 3274 h->root.u.def.section = s; 3275 h->root.u.def.value = h->plt.offset; 3276 } 3277 } 3278 } 3279 3280 /* Make room for this entry. */ 3281 if (use_plt_got) 3282 got_s->size += sizeof (elf_x86_64_legacy_plt2_entry); 3283 else 3284 { 3285 s->size += plt_entry_size; 3286 if (bnd_s) 3287 bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry); 3288 3289 /* We also need to make an entry in the .got.plt section, 3290 which will be placed in the .got section by the linker 3291 script. */ 3292 htab->elf.sgotplt->size += GOT_ENTRY_SIZE; 3293 3294 /* There should be no PLT relocation against resolved 3295 undefined weak symbol in executable. */ 3296 if (!resolved_to_zero) 3297 { 3298 /* We also need to make an entry in the .rela.plt 3299 section. */ 3300 htab->elf.srelplt->size += bed->s->sizeof_rela; 3301 htab->elf.srelplt->reloc_count++; 3302 } 3303 } 3304 } 3305 else 3306 { 3307 eh->plt_got.offset = (bfd_vma) -1; 3308 h->plt.offset = (bfd_vma) -1; 3309 h->needs_plt = 0; 3310 } 3311 } 3312 else 3313 { 3314 eh->plt_got.offset = (bfd_vma) -1; 3315 h->plt.offset = (bfd_vma) -1; 3316 h->needs_plt = 0; 3317 } 3318 3319 eh->tlsdesc_got = (bfd_vma) -1; 3320 3321 /* If R_X86_64_GOTTPOFF symbol is now local to the binary, 3322 make it a R_X86_64_TPOFF32 requiring no GOT entry. */ 3323 if (h->got.refcount > 0 3324 && bfd_link_executable (info) 3325 && h->dynindx == -1 3326 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE) 3327 { 3328 h->got.offset = (bfd_vma) -1; 3329 } 3330 else if (h->got.refcount > 0) 3331 { 3332 asection *s; 3333 bfd_boolean dyn; 3334 int tls_type = elf_x86_64_hash_entry (h)->tls_type; 3335 3336 /* Make sure this symbol is output as a dynamic symbol. 3337 Undefined weak syms won't yet be marked as dynamic. */ 3338 if (h->dynindx == -1 3339 && !h->forced_local 3340 && !resolved_to_zero) 3341 { 3342 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3343 return FALSE; 3344 } 3345 3346 if (GOT_TLS_GDESC_P (tls_type)) 3347 { 3348 eh->tlsdesc_got = htab->elf.sgotplt->size 3349 - elf_x86_64_compute_jump_table_size (htab); 3350 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE; 3351 h->got.offset = (bfd_vma) -2; 3352 } 3353 if (! GOT_TLS_GDESC_P (tls_type) 3354 || GOT_TLS_GD_P (tls_type)) 3355 { 3356 s = htab->elf.sgot; 3357 h->got.offset = s->size; 3358 s->size += GOT_ENTRY_SIZE; 3359 if (GOT_TLS_GD_P (tls_type)) 3360 s->size += GOT_ENTRY_SIZE; 3361 } 3362 dyn = htab->elf.dynamic_sections_created; 3363 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol 3364 and two if global. R_X86_64_GOTTPOFF needs one dynamic 3365 relocation. No dynamic relocation against resolved undefined 3366 weak symbol in executable. */ 3367 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1) 3368 || tls_type == GOT_TLS_IE) 3369 htab->elf.srelgot->size += bed->s->sizeof_rela; 3370 else if (GOT_TLS_GD_P (tls_type)) 3371 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela; 3372 else if (! GOT_TLS_GDESC_P (tls_type) 3373 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3374 && !resolved_to_zero) 3375 || h->root.type != bfd_link_hash_undefweak) 3376 && (bfd_link_pic (info) 3377 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 3378 htab->elf.srelgot->size += bed->s->sizeof_rela; 3379 if (GOT_TLS_GDESC_P (tls_type)) 3380 { 3381 htab->elf.srelplt->size += bed->s->sizeof_rela; 3382 htab->tlsdesc_plt = (bfd_vma) -1; 3383 } 3384 } 3385 else 3386 h->got.offset = (bfd_vma) -1; 3387 3388 if (eh->dyn_relocs == NULL) 3389 return TRUE; 3390 3391 /* In the shared -Bsymbolic case, discard space allocated for 3392 dynamic pc-relative relocs against symbols which turn out to be 3393 defined in regular objects. For the normal shared case, discard 3394 space for pc-relative relocs that have become local due to symbol 3395 visibility changes. */ 3396 3397 if (bfd_link_pic (info)) 3398 { 3399 /* Relocs that use pc_count are those that appear on a call 3400 insn, or certain REL relocs that can generated via assembly. 3401 We want calls to protected symbols to resolve directly to the 3402 function rather than going via the plt. If people want 3403 function pointer comparisons to work as expected then they 3404 should avoid writing weird assembly. */ 3405 if (SYMBOL_CALLS_LOCAL (info, h)) 3406 { 3407 struct elf_dyn_relocs **pp; 3408 3409 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 3410 { 3411 p->count -= p->pc_count; 3412 p->pc_count = 0; 3413 if (p->count == 0) 3414 *pp = p->next; 3415 else 3416 pp = &p->next; 3417 } 3418 } 3419 3420 /* Also discard relocs on undefined weak syms with non-default 3421 visibility or in PIE. */ 3422 if (eh->dyn_relocs != NULL) 3423 { 3424 if (h->root.type == bfd_link_hash_undefweak) 3425 { 3426 /* Undefined weak symbol is never bound locally in shared 3427 library. */ 3428 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 3429 || resolved_to_zero) 3430 eh->dyn_relocs = NULL; 3431 else if (h->dynindx == -1 3432 && ! h->forced_local 3433 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 3434 return FALSE; 3435 } 3436 /* For PIE, discard space for pc-relative relocs against 3437 symbols which turn out to need copy relocs. */ 3438 else if (bfd_link_executable (info) 3439 && (h->needs_copy || eh->needs_copy) 3440 && h->def_dynamic 3441 && !h->def_regular) 3442 { 3443 struct elf_dyn_relocs **pp; 3444 3445 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 3446 { 3447 if (p->pc_count != 0) 3448 *pp = p->next; 3449 else 3450 pp = &p->next; 3451 } 3452 } 3453 } 3454 } 3455 else if (ELIMINATE_COPY_RELOCS) 3456 { 3457 /* For the non-shared case, discard space for relocs against 3458 symbols which turn out to need copy relocs or are not 3459 dynamic. Keep dynamic relocations for run-time function 3460 pointer initialization. */ 3461 3462 if ((!h->non_got_ref 3463 || eh->func_pointer_refcount > 0 3464 || (h->root.type == bfd_link_hash_undefweak 3465 && !resolved_to_zero)) 3466 && ((h->def_dynamic 3467 && !h->def_regular) 3468 || (htab->elf.dynamic_sections_created 3469 && (h->root.type == bfd_link_hash_undefweak 3470 || h->root.type == bfd_link_hash_undefined)))) 3471 { 3472 /* Make sure this symbol is output as a dynamic symbol. 3473 Undefined weak syms won't yet be marked as dynamic. */ 3474 if (h->dynindx == -1 3475 && ! h->forced_local 3476 && ! resolved_to_zero 3477 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 3478 return FALSE; 3479 3480 /* If that succeeded, we know we'll be keeping all the 3481 relocs. */ 3482 if (h->dynindx != -1) 3483 goto keep; 3484 } 3485 3486 eh->dyn_relocs = NULL; 3487 eh->func_pointer_refcount = 0; 3488 3489 keep: ; 3490 } 3491 3492 /* Finally, allocate space. */ 3493 for (p = eh->dyn_relocs; p != NULL; p = p->next) 3494 { 3495 asection * sreloc; 3496 3497 sreloc = elf_section_data (p->sec)->sreloc; 3498 3499 BFD_ASSERT (sreloc != NULL); 3500 3501 sreloc->size += p->count * bed->s->sizeof_rela; 3502 } 3503 3504 return TRUE; 3505} 3506 3507/* Allocate space in .plt, .got and associated reloc sections for 3508 local dynamic relocs. */ 3509 3510static bfd_boolean 3511elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf) 3512{ 3513 struct elf_link_hash_entry *h 3514 = (struct elf_link_hash_entry *) *slot; 3515 3516 if (h->type != STT_GNU_IFUNC 3517 || !h->def_regular 3518 || !h->ref_regular 3519 || !h->forced_local 3520 || h->root.type != bfd_link_hash_defined) 3521 abort (); 3522 3523 return elf_x86_64_allocate_dynrelocs (h, inf); 3524} 3525 3526/* Find any dynamic relocs that apply to read-only sections. */ 3527 3528static bfd_boolean 3529elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h, 3530 void * inf) 3531{ 3532 struct elf_x86_64_link_hash_entry *eh; 3533 struct elf_dyn_relocs *p; 3534 3535 /* Skip local IFUNC symbols. */ 3536 if (h->forced_local && h->type == STT_GNU_IFUNC) 3537 return TRUE; 3538 3539 eh = (struct elf_x86_64_link_hash_entry *) h; 3540 for (p = eh->dyn_relocs; p != NULL; p = p->next) 3541 { 3542 asection *s = p->sec->output_section; 3543 3544 if (s != NULL && (s->flags & SEC_READONLY) != 0) 3545 { 3546 struct bfd_link_info *info = (struct bfd_link_info *) inf; 3547 3548 info->flags |= DF_TEXTREL; 3549 3550 if ((info->warn_shared_textrel && bfd_link_pic (info)) 3551 || info->error_textrel) 3552 /* xgettext:c-format */ 3553 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"), 3554 p->sec->owner, h->root.root.string, 3555 p->sec); 3556 3557 /* Not an error, just cut short the traversal. */ 3558 return FALSE; 3559 } 3560 } 3561 return TRUE; 3562} 3563 3564/* Convert load via the GOT slot to load immediate. */ 3565 3566static bfd_boolean 3567elf_x86_64_convert_load (bfd *abfd, asection *sec, 3568 struct bfd_link_info *link_info) 3569{ 3570 Elf_Internal_Shdr *symtab_hdr; 3571 Elf_Internal_Rela *internal_relocs; 3572 Elf_Internal_Rela *irel, *irelend; 3573 bfd_byte *contents; 3574 struct elf_x86_64_link_hash_table *htab; 3575 bfd_boolean changed; 3576 bfd_signed_vma *local_got_refcounts; 3577 3578 /* Don't even try to convert non-ELF outputs. */ 3579 if (!is_elf_hash_table (link_info->hash)) 3580 return FALSE; 3581 3582 /* Nothing to do if there is no need or no output. */ 3583 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC) 3584 || sec->need_convert_load == 0 3585 || bfd_is_abs_section (sec->output_section)) 3586 return TRUE; 3587 3588 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3589 3590 /* Load the relocations for this section. */ 3591 internal_relocs = (_bfd_elf_link_read_relocs 3592 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 3593 link_info->keep_memory)); 3594 if (internal_relocs == NULL) 3595 return FALSE; 3596 3597 changed = FALSE; 3598 htab = elf_x86_64_hash_table (link_info); 3599 local_got_refcounts = elf_local_got_refcounts (abfd); 3600 3601 /* Get the section contents. */ 3602 if (elf_section_data (sec)->this_hdr.contents != NULL) 3603 contents = elf_section_data (sec)->this_hdr.contents; 3604 else 3605 { 3606 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 3607 goto error_return; 3608 } 3609 3610 irelend = internal_relocs + sec->reloc_count; 3611 for (irel = internal_relocs; irel < irelend; irel++) 3612 { 3613 unsigned int r_type = ELF32_R_TYPE (irel->r_info); 3614 unsigned int r_symndx; 3615 struct elf_link_hash_entry *h; 3616 bfd_boolean converted; 3617 3618 if (r_type != R_X86_64_GOTPCRELX 3619 && r_type != R_X86_64_REX_GOTPCRELX 3620 && r_type != R_X86_64_GOTPCREL) 3621 continue; 3622 3623 r_symndx = htab->r_sym (irel->r_info); 3624 if (r_symndx < symtab_hdr->sh_info) 3625 h = elf_x86_64_get_local_sym_hash (htab, sec->owner, 3626 (const Elf_Internal_Rela *) irel, 3627 FALSE); 3628 else 3629 { 3630 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info]; 3631 while (h->root.type == bfd_link_hash_indirect 3632 || h->root.type == bfd_link_hash_warning) 3633 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3634 } 3635 3636 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */ 3637 if (h != NULL && h->type == STT_GNU_IFUNC) 3638 continue; 3639 3640 converted = FALSE; 3641 if (!elf_x86_64_convert_load_reloc (abfd, sec, contents, irel, h, 3642 &converted, link_info)) 3643 goto error_return; 3644 3645 if (converted) 3646 { 3647 changed = converted; 3648 if (h) 3649 { 3650 if (h->got.refcount > 0) 3651 h->got.refcount -= 1; 3652 } 3653 else 3654 { 3655 if (local_got_refcounts != NULL 3656 && local_got_refcounts[r_symndx] > 0) 3657 local_got_refcounts[r_symndx] -= 1; 3658 } 3659 } 3660 } 3661 3662 if (contents != NULL 3663 && elf_section_data (sec)->this_hdr.contents != contents) 3664 { 3665 if (!changed && !link_info->keep_memory) 3666 free (contents); 3667 else 3668 { 3669 /* Cache the section contents for elf_link_input_bfd. */ 3670 elf_section_data (sec)->this_hdr.contents = contents; 3671 } 3672 } 3673 3674 if (elf_section_data (sec)->relocs != internal_relocs) 3675 { 3676 if (!changed) 3677 free (internal_relocs); 3678 else 3679 elf_section_data (sec)->relocs = internal_relocs; 3680 } 3681 3682 return TRUE; 3683 3684 error_return: 3685 if (contents != NULL 3686 && elf_section_data (sec)->this_hdr.contents != contents) 3687 free (contents); 3688 if (internal_relocs != NULL 3689 && elf_section_data (sec)->relocs != internal_relocs) 3690 free (internal_relocs); 3691 return FALSE; 3692} 3693 3694/* Set the sizes of the dynamic sections. */ 3695 3696static bfd_boolean 3697elf_x86_64_size_dynamic_sections (bfd *output_bfd, 3698 struct bfd_link_info *info) 3699{ 3700 struct elf_x86_64_link_hash_table *htab; 3701 bfd *dynobj; 3702 asection *s; 3703 bfd_boolean relocs; 3704 bfd *ibfd; 3705 const struct elf_backend_data *bed; 3706 const struct elf_x86_64_backend_data *arch_data; 3707 3708 htab = elf_x86_64_hash_table (info); 3709 if (htab == NULL) 3710 return FALSE; 3711 bed = get_elf_backend_data (output_bfd); 3712 3713 dynobj = htab->elf.dynobj; 3714 if (dynobj == NULL) 3715 abort (); 3716 3717 /* Set up .got offsets for local syms, and space for local dynamic 3718 relocs. */ 3719 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 3720 { 3721 bfd_signed_vma *local_got; 3722 bfd_signed_vma *end_local_got; 3723 char *local_tls_type; 3724 bfd_vma *local_tlsdesc_gotent; 3725 bfd_size_type locsymcount; 3726 Elf_Internal_Shdr *symtab_hdr; 3727 asection *srel; 3728 3729 if (! is_x86_64_elf (ibfd)) 3730 continue; 3731 3732 for (s = ibfd->sections; s != NULL; s = s->next) 3733 { 3734 struct elf_dyn_relocs *p; 3735 3736 if (!elf_x86_64_convert_load (ibfd, s, info)) 3737 return FALSE; 3738 3739 for (p = (struct elf_dyn_relocs *) 3740 (elf_section_data (s)->local_dynrel); 3741 p != NULL; 3742 p = p->next) 3743 { 3744 if (!bfd_is_abs_section (p->sec) 3745 && bfd_is_abs_section (p->sec->output_section)) 3746 { 3747 /* Input section has been discarded, either because 3748 it is a copy of a linkonce section or due to 3749 linker script /DISCARD/, so we'll be discarding 3750 the relocs too. */ 3751 } 3752 else if (p->count != 0) 3753 { 3754 srel = elf_section_data (p->sec)->sreloc; 3755 srel->size += p->count * bed->s->sizeof_rela; 3756 if ((p->sec->output_section->flags & SEC_READONLY) != 0 3757 && (info->flags & DF_TEXTREL) == 0) 3758 { 3759 info->flags |= DF_TEXTREL; 3760 if ((info->warn_shared_textrel && bfd_link_pic (info)) 3761 || info->error_textrel) 3762 /* xgettext:c-format */ 3763 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"), 3764 p->sec->owner, p->sec); 3765 } 3766 } 3767 } 3768 } 3769 3770 local_got = elf_local_got_refcounts (ibfd); 3771 if (!local_got) 3772 continue; 3773 3774 symtab_hdr = &elf_symtab_hdr (ibfd); 3775 locsymcount = symtab_hdr->sh_info; 3776 end_local_got = local_got + locsymcount; 3777 local_tls_type = elf_x86_64_local_got_tls_type (ibfd); 3778 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd); 3779 s = htab->elf.sgot; 3780 srel = htab->elf.srelgot; 3781 for (; local_got < end_local_got; 3782 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent) 3783 { 3784 *local_tlsdesc_gotent = (bfd_vma) -1; 3785 if (*local_got > 0) 3786 { 3787 if (GOT_TLS_GDESC_P (*local_tls_type)) 3788 { 3789 *local_tlsdesc_gotent = htab->elf.sgotplt->size 3790 - elf_x86_64_compute_jump_table_size (htab); 3791 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE; 3792 *local_got = (bfd_vma) -2; 3793 } 3794 if (! GOT_TLS_GDESC_P (*local_tls_type) 3795 || GOT_TLS_GD_P (*local_tls_type)) 3796 { 3797 *local_got = s->size; 3798 s->size += GOT_ENTRY_SIZE; 3799 if (GOT_TLS_GD_P (*local_tls_type)) 3800 s->size += GOT_ENTRY_SIZE; 3801 } 3802 if (bfd_link_pic (info) 3803 || GOT_TLS_GD_ANY_P (*local_tls_type) 3804 || *local_tls_type == GOT_TLS_IE) 3805 { 3806 if (GOT_TLS_GDESC_P (*local_tls_type)) 3807 { 3808 htab->elf.srelplt->size 3809 += bed->s->sizeof_rela; 3810 htab->tlsdesc_plt = (bfd_vma) -1; 3811 } 3812 if (! GOT_TLS_GDESC_P (*local_tls_type) 3813 || GOT_TLS_GD_P (*local_tls_type)) 3814 srel->size += bed->s->sizeof_rela; 3815 } 3816 } 3817 else 3818 *local_got = (bfd_vma) -1; 3819 } 3820 } 3821 3822 if (htab->tls_ld_got.refcount > 0) 3823 { 3824 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD 3825 relocs. */ 3826 htab->tls_ld_got.offset = htab->elf.sgot->size; 3827 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE; 3828 htab->elf.srelgot->size += bed->s->sizeof_rela; 3829 } 3830 else 3831 htab->tls_ld_got.offset = -1; 3832 3833 /* Allocate global sym .plt and .got entries, and space for global 3834 sym dynamic relocs. */ 3835 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs, 3836 info); 3837 3838 /* Allocate .plt and .got entries, and space for local symbols. */ 3839 htab_traverse (htab->loc_hash_table, 3840 elf_x86_64_allocate_local_dynrelocs, 3841 info); 3842 3843 /* For every jump slot reserved in the sgotplt, reloc_count is 3844 incremented. However, when we reserve space for TLS descriptors, 3845 it's not incremented, so in order to compute the space reserved 3846 for them, it suffices to multiply the reloc count by the jump 3847 slot size. 3848 3849 PR ld/13302: We start next_irelative_index at the end of .rela.plt 3850 so that R_X86_64_IRELATIVE entries come last. */ 3851 if (htab->elf.srelplt) 3852 { 3853 htab->sgotplt_jump_table_size 3854 = elf_x86_64_compute_jump_table_size (htab); 3855 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1; 3856 } 3857 else if (htab->elf.irelplt) 3858 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1; 3859 3860 if (htab->tlsdesc_plt) 3861 { 3862 /* If we're not using lazy TLS relocations, don't generate the 3863 PLT and GOT entries they require. */ 3864 if ((info->flags & DF_BIND_NOW)) 3865 htab->tlsdesc_plt = 0; 3866 else 3867 { 3868 htab->tlsdesc_got = htab->elf.sgot->size; 3869 htab->elf.sgot->size += GOT_ENTRY_SIZE; 3870 /* Reserve room for the initial entry. 3871 FIXME: we could probably do away with it in this case. */ 3872 if (htab->elf.splt->size == 0) 3873 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd); 3874 htab->tlsdesc_plt = htab->elf.splt->size; 3875 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd); 3876 } 3877 } 3878 3879 if (htab->elf.sgotplt) 3880 { 3881 /* Don't allocate .got.plt section if there are no GOT nor PLT 3882 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */ 3883 if ((htab->elf.hgot == NULL 3884 || !htab->elf.hgot->ref_regular_nonweak) 3885 && (htab->elf.sgotplt->size 3886 == get_elf_backend_data (output_bfd)->got_header_size) 3887 && (htab->elf.splt == NULL 3888 || htab->elf.splt->size == 0) 3889 && (htab->elf.sgot == NULL 3890 || htab->elf.sgot->size == 0) 3891 && (htab->elf.iplt == NULL 3892 || htab->elf.iplt->size == 0) 3893 && (htab->elf.igotplt == NULL 3894 || htab->elf.igotplt->size == 0)) 3895 htab->elf.sgotplt->size = 0; 3896 } 3897 3898 arch_data = (htab->plt_bnd != NULL 3899 ? &elf_x86_64_bnd_arch_bed 3900 : get_elf_x86_64_arch_data (bed)); 3901 3902 if (_bfd_elf_eh_frame_present (info)) 3903 { 3904 if (htab->plt_eh_frame != NULL 3905 && htab->elf.splt != NULL 3906 && htab->elf.splt->size != 0 3907 && !bfd_is_abs_section (htab->elf.splt->output_section)) 3908 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size; 3909 3910 if (htab->plt_got_eh_frame != NULL 3911 && htab->plt_got != NULL 3912 && htab->plt_got->size != 0 3913 && !bfd_is_abs_section (htab->plt_got->output_section)) 3914 htab->plt_got_eh_frame->size = arch_data->eh_frame_plt_got_size; 3915 3916 /* Unwind info for .plt.bnd and .plt.got sections are 3917 identical. */ 3918 if (htab->plt_bnd_eh_frame != NULL 3919 && htab->plt_bnd != NULL 3920 && htab->plt_bnd->size != 0 3921 && !bfd_is_abs_section (htab->plt_bnd->output_section)) 3922 htab->plt_bnd_eh_frame->size = arch_data->eh_frame_plt_got_size; 3923 } 3924 3925 /* We now have determined the sizes of the various dynamic sections. 3926 Allocate memory for them. */ 3927 relocs = FALSE; 3928 for (s = dynobj->sections; s != NULL; s = s->next) 3929 { 3930 if ((s->flags & SEC_LINKER_CREATED) == 0) 3931 continue; 3932 3933 if (s == htab->elf.splt 3934 || s == htab->elf.sgot 3935 || s == htab->elf.sgotplt 3936 || s == htab->elf.iplt 3937 || s == htab->elf.igotplt 3938 || s == htab->plt_bnd 3939 || s == htab->plt_got 3940 || s == htab->plt_eh_frame 3941 || s == htab->plt_got_eh_frame 3942 || s == htab->plt_bnd_eh_frame 3943 || s == htab->elf.sdynbss 3944 || s == htab->elf.sdynrelro) 3945 { 3946 /* Strip this section if we don't need it; see the 3947 comment below. */ 3948 } 3949 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 3950 { 3951 if (s->size != 0 && s != htab->elf.srelplt) 3952 relocs = TRUE; 3953 3954 /* We use the reloc_count field as a counter if we need 3955 to copy relocs into the output file. */ 3956 if (s != htab->elf.srelplt) 3957 s->reloc_count = 0; 3958 } 3959 else 3960 { 3961 /* It's not one of our sections, so don't allocate space. */ 3962 continue; 3963 } 3964 3965 if (s->size == 0) 3966 { 3967 /* If we don't need this section, strip it from the 3968 output file. This is mostly to handle .rela.bss and 3969 .rela.plt. We must create both sections in 3970 create_dynamic_sections, because they must be created 3971 before the linker maps input sections to output 3972 sections. The linker does that before 3973 adjust_dynamic_symbol is called, and it is that 3974 function which decides whether anything needs to go 3975 into these sections. */ 3976 3977 s->flags |= SEC_EXCLUDE; 3978 continue; 3979 } 3980 3981 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3982 continue; 3983 3984 /* Allocate memory for the section contents. We use bfd_zalloc 3985 here in case unused entries are not reclaimed before the 3986 section's contents are written out. This should not happen, 3987 but this way if it does, we get a R_X86_64_NONE reloc instead 3988 of garbage. */ 3989 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3990 if (s->contents == NULL) 3991 return FALSE; 3992 } 3993 3994 if (htab->plt_eh_frame != NULL 3995 && htab->plt_eh_frame->contents != NULL) 3996 { 3997 memcpy (htab->plt_eh_frame->contents, 3998 arch_data->eh_frame_plt, htab->plt_eh_frame->size); 3999 bfd_put_32 (dynobj, htab->elf.splt->size, 4000 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); 4001 } 4002 4003 if (htab->plt_got_eh_frame != NULL 4004 && htab->plt_got_eh_frame->contents != NULL) 4005 { 4006 memcpy (htab->plt_got_eh_frame->contents, 4007 arch_data->eh_frame_plt_got, 4008 htab->plt_got_eh_frame->size); 4009 bfd_put_32 (dynobj, htab->plt_got->size, 4010 (htab->plt_got_eh_frame->contents 4011 + PLT_FDE_LEN_OFFSET)); 4012 } 4013 4014 if (htab->plt_bnd_eh_frame != NULL 4015 && htab->plt_bnd_eh_frame->contents != NULL) 4016 { 4017 memcpy (htab->plt_bnd_eh_frame->contents, 4018 arch_data->eh_frame_plt_got, 4019 htab->plt_bnd_eh_frame->size); 4020 bfd_put_32 (dynobj, htab->plt_bnd->size, 4021 (htab->plt_bnd_eh_frame->contents 4022 + PLT_FDE_LEN_OFFSET)); 4023 } 4024 4025 if (htab->elf.dynamic_sections_created) 4026 { 4027 /* Add some entries to the .dynamic section. We fill in the 4028 values later, in elf_x86_64_finish_dynamic_sections, but we 4029 must add the entries now so that we get the correct size for 4030 the .dynamic section. The DT_DEBUG entry is filled in by the 4031 dynamic linker and used by the debugger. */ 4032#define add_dynamic_entry(TAG, VAL) \ 4033 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 4034 4035 if (bfd_link_executable (info)) 4036 { 4037 if (!add_dynamic_entry (DT_DEBUG, 0)) 4038 return FALSE; 4039 } 4040 4041 if (htab->elf.splt->size != 0) 4042 { 4043 /* DT_PLTGOT is used by prelink even if there is no PLT 4044 relocation. */ 4045 if (!add_dynamic_entry (DT_PLTGOT, 0)) 4046 return FALSE; 4047 4048 if (htab->elf.srelplt->size != 0) 4049 { 4050 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 4051 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 4052 || !add_dynamic_entry (DT_JMPREL, 0)) 4053 return FALSE; 4054 } 4055 4056 if (htab->tlsdesc_plt 4057 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 4058 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 4059 return FALSE; 4060 } 4061 4062 if (relocs) 4063 { 4064 if (!add_dynamic_entry (DT_RELA, 0) 4065 || !add_dynamic_entry (DT_RELASZ, 0) 4066 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela)) 4067 return FALSE; 4068 4069 /* If any dynamic relocs apply to a read-only section, 4070 then we need a DT_TEXTREL entry. */ 4071 if ((info->flags & DF_TEXTREL) == 0) 4072 elf_link_hash_traverse (&htab->elf, 4073 elf_x86_64_readonly_dynrelocs, 4074 info); 4075 4076 if ((info->flags & DF_TEXTREL) != 0) 4077 { 4078 if (htab->readonly_dynrelocs_against_ifunc) 4079 { 4080 info->callbacks->einfo 4081 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n")); 4082 bfd_set_error (bfd_error_bad_value); 4083 return FALSE; 4084 } 4085 4086 if (!add_dynamic_entry (DT_TEXTREL, 0)) 4087 return FALSE; 4088 } 4089 } 4090 } 4091#undef add_dynamic_entry 4092 4093 return TRUE; 4094} 4095 4096static bfd_boolean 4097elf_x86_64_always_size_sections (bfd *output_bfd, 4098 struct bfd_link_info *info) 4099{ 4100 asection *tls_sec = elf_hash_table (info)->tls_sec; 4101 4102 if (tls_sec) 4103 { 4104 struct elf_link_hash_entry *tlsbase; 4105 4106 tlsbase = elf_link_hash_lookup (elf_hash_table (info), 4107 "_TLS_MODULE_BASE_", 4108 FALSE, FALSE, FALSE); 4109 4110 if (tlsbase && tlsbase->type == STT_TLS) 4111 { 4112 struct elf_x86_64_link_hash_table *htab; 4113 struct bfd_link_hash_entry *bh = NULL; 4114 const struct elf_backend_data *bed 4115 = get_elf_backend_data (output_bfd); 4116 4117 htab = elf_x86_64_hash_table (info); 4118 if (htab == NULL) 4119 return FALSE; 4120 4121 if (!(_bfd_generic_link_add_one_symbol 4122 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL, 4123 tls_sec, 0, NULL, FALSE, 4124 bed->collect, &bh))) 4125 return FALSE; 4126 4127 htab->tls_module_base = bh; 4128 4129 tlsbase = (struct elf_link_hash_entry *)bh; 4130 tlsbase->def_regular = 1; 4131 tlsbase->other = STV_HIDDEN; 4132 tlsbase->root.linker_def = 1; 4133 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE); 4134 } 4135 } 4136 4137 return TRUE; 4138} 4139 4140/* _TLS_MODULE_BASE_ needs to be treated especially when linking 4141 executables. Rather than setting it to the beginning of the TLS 4142 section, we have to set it to the end. This function may be called 4143 multiple times, it is idempotent. */ 4144 4145static void 4146elf_x86_64_set_tls_module_base (struct bfd_link_info *info) 4147{ 4148 struct elf_x86_64_link_hash_table *htab; 4149 struct bfd_link_hash_entry *base; 4150 4151 if (!bfd_link_executable (info)) 4152 return; 4153 4154 htab = elf_x86_64_hash_table (info); 4155 if (htab == NULL) 4156 return; 4157 4158 base = htab->tls_module_base; 4159 if (base == NULL) 4160 return; 4161 4162 base->u.def.value = htab->elf.tls_size; 4163} 4164 4165/* Return the base VMA address which should be subtracted from real addresses 4166 when resolving @dtpoff relocation. 4167 This is PT_TLS segment p_vaddr. */ 4168 4169static bfd_vma 4170elf_x86_64_dtpoff_base (struct bfd_link_info *info) 4171{ 4172 /* If tls_sec is NULL, we should have signalled an error already. */ 4173 if (elf_hash_table (info)->tls_sec == NULL) 4174 return 0; 4175 return elf_hash_table (info)->tls_sec->vma; 4176} 4177 4178/* Return the relocation value for @tpoff relocation 4179 if STT_TLS virtual address is ADDRESS. */ 4180 4181static bfd_vma 4182elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address) 4183{ 4184 struct elf_link_hash_table *htab = elf_hash_table (info); 4185 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd); 4186 bfd_vma static_tls_size; 4187 4188 /* If tls_segment is NULL, we should have signalled an error already. */ 4189 if (htab->tls_sec == NULL) 4190 return 0; 4191 4192 /* Consider special static TLS alignment requirements. */ 4193 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment); 4194 return address - static_tls_size - htab->tls_sec->vma; 4195} 4196 4197/* Is the instruction before OFFSET in CONTENTS a 32bit relative 4198 branch? */ 4199 4200static bfd_boolean 4201is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset) 4202{ 4203 /* Opcode Instruction 4204 0xe8 call 4205 0xe9 jump 4206 0x0f 0x8x conditional jump */ 4207 return ((offset > 0 4208 && (contents [offset - 1] == 0xe8 4209 || contents [offset - 1] == 0xe9)) 4210 || (offset > 1 4211 && contents [offset - 2] == 0x0f 4212 && (contents [offset - 1] & 0xf0) == 0x80)); 4213} 4214 4215/* Relocate an x86_64 ELF section. */ 4216 4217static bfd_boolean 4218elf_x86_64_relocate_section (bfd *output_bfd, 4219 struct bfd_link_info *info, 4220 bfd *input_bfd, 4221 asection *input_section, 4222 bfd_byte *contents, 4223 Elf_Internal_Rela *relocs, 4224 Elf_Internal_Sym *local_syms, 4225 asection **local_sections) 4226{ 4227 struct elf_x86_64_link_hash_table *htab; 4228 Elf_Internal_Shdr *symtab_hdr; 4229 struct elf_link_hash_entry **sym_hashes; 4230 bfd_vma *local_got_offsets; 4231 bfd_vma *local_tlsdesc_gotents; 4232 Elf_Internal_Rela *rel; 4233 Elf_Internal_Rela *wrel; 4234 Elf_Internal_Rela *relend; 4235 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd); 4236 4237 BFD_ASSERT (is_x86_64_elf (input_bfd)); 4238 4239 /* Skip if check_relocs failed. */ 4240 if (input_section->check_relocs_failed) 4241 return FALSE; 4242 4243 htab = elf_x86_64_hash_table (info); 4244 if (htab == NULL) 4245 return FALSE; 4246 symtab_hdr = &elf_symtab_hdr (input_bfd); 4247 sym_hashes = elf_sym_hashes (input_bfd); 4248 local_got_offsets = elf_local_got_offsets (input_bfd); 4249 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd); 4250 4251 elf_x86_64_set_tls_module_base (info); 4252 4253 rel = wrel = relocs; 4254 relend = relocs + input_section->reloc_count; 4255 for (; rel < relend; wrel++, rel++) 4256 { 4257 unsigned int r_type; 4258 reloc_howto_type *howto; 4259 unsigned long r_symndx; 4260 struct elf_link_hash_entry *h; 4261 struct elf_x86_64_link_hash_entry *eh; 4262 Elf_Internal_Sym *sym; 4263 asection *sec; 4264 bfd_vma off, offplt, plt_offset; 4265 bfd_vma relocation; 4266 bfd_boolean unresolved_reloc; 4267 bfd_reloc_status_type r; 4268 int tls_type; 4269 asection *base_got, *resolved_plt; 4270 bfd_vma st_size; 4271 bfd_boolean resolved_to_zero; 4272 4273 r_type = ELF32_R_TYPE (rel->r_info); 4274 if (r_type == (int) R_X86_64_GNU_VTINHERIT 4275 || r_type == (int) R_X86_64_GNU_VTENTRY) 4276 { 4277 if (wrel != rel) 4278 *wrel = *rel; 4279 continue; 4280 } 4281 4282 if (r_type >= (int) R_X86_64_standard) 4283 { 4284 _bfd_error_handler 4285 /* xgettext:c-format */ 4286 (_("%B: unrecognized relocation (0x%x) in section `%A'"), 4287 input_bfd, input_section, r_type); 4288 bfd_set_error (bfd_error_bad_value); 4289 return FALSE; 4290 } 4291 4292 if (r_type != (int) R_X86_64_32 4293 || ABI_64_P (output_bfd)) 4294 howto = x86_64_elf_howto_table + r_type; 4295 else 4296 howto = (x86_64_elf_howto_table 4297 + ARRAY_SIZE (x86_64_elf_howto_table) - 1); 4298 r_symndx = htab->r_sym (rel->r_info); 4299 h = NULL; 4300 sym = NULL; 4301 sec = NULL; 4302 unresolved_reloc = FALSE; 4303 if (r_symndx < symtab_hdr->sh_info) 4304 { 4305 sym = local_syms + r_symndx; 4306 sec = local_sections[r_symndx]; 4307 4308 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, 4309 &sec, rel); 4310 st_size = sym->st_size; 4311 4312 /* Relocate against local STT_GNU_IFUNC symbol. */ 4313 if (!bfd_link_relocatable (info) 4314 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 4315 { 4316 h = elf_x86_64_get_local_sym_hash (htab, input_bfd, 4317 rel, FALSE); 4318 if (h == NULL) 4319 abort (); 4320 4321 /* Set STT_GNU_IFUNC symbol value. */ 4322 h->root.u.def.value = sym->st_value; 4323 h->root.u.def.section = sec; 4324 } 4325 } 4326 else 4327 { 4328 bfd_boolean warned ATTRIBUTE_UNUSED; 4329 bfd_boolean ignored ATTRIBUTE_UNUSED; 4330 4331 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 4332 r_symndx, symtab_hdr, sym_hashes, 4333 h, sec, relocation, 4334 unresolved_reloc, warned, ignored); 4335 st_size = h->size; 4336 } 4337 4338 if (sec != NULL && discarded_section (sec)) 4339 { 4340 _bfd_clear_contents (howto, input_bfd, input_section, 4341 contents + rel->r_offset); 4342 wrel->r_offset = rel->r_offset; 4343 wrel->r_info = 0; 4344 wrel->r_addend = 0; 4345 4346 /* For ld -r, remove relocations in debug sections against 4347 sections defined in discarded sections. Not done for 4348 eh_frame editing code expects to be present. */ 4349 if (bfd_link_relocatable (info) 4350 && (input_section->flags & SEC_DEBUGGING)) 4351 wrel--; 4352 4353 continue; 4354 } 4355 4356 if (bfd_link_relocatable (info)) 4357 { 4358 if (wrel != rel) 4359 *wrel = *rel; 4360 continue; 4361 } 4362 4363 if (rel->r_addend == 0 && !ABI_64_P (output_bfd)) 4364 { 4365 if (r_type == R_X86_64_64) 4366 { 4367 /* For x32, treat R_X86_64_64 like R_X86_64_32 and 4368 zero-extend it to 64bit if addend is zero. */ 4369 r_type = R_X86_64_32; 4370 memset (contents + rel->r_offset + 4, 0, 4); 4371 } 4372 else if (r_type == R_X86_64_SIZE64) 4373 { 4374 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and 4375 zero-extend it to 64bit if addend is zero. */ 4376 r_type = R_X86_64_SIZE32; 4377 memset (contents + rel->r_offset + 4, 0, 4); 4378 } 4379 } 4380 4381 eh = (struct elf_x86_64_link_hash_entry *) h; 4382 4383 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle 4384 it here if it is defined in a non-shared object. */ 4385 if (h != NULL 4386 && h->type == STT_GNU_IFUNC 4387 && h->def_regular) 4388 { 4389 bfd_vma plt_index; 4390 const char *name; 4391 4392 if ((input_section->flags & SEC_ALLOC) == 0) 4393 { 4394 /* Dynamic relocs are not propagated for SEC_DEBUGGING 4395 sections because such sections are not SEC_ALLOC and 4396 thus ld.so will not process them. */ 4397 if ((input_section->flags & SEC_DEBUGGING) != 0) 4398 continue; 4399 abort (); 4400 } 4401 4402 switch (r_type) 4403 { 4404 default: 4405 break; 4406 4407 case R_X86_64_GOTPCREL: 4408 case R_X86_64_GOTPCRELX: 4409 case R_X86_64_REX_GOTPCRELX: 4410 case R_X86_64_GOTPCREL64: 4411 base_got = htab->elf.sgot; 4412 off = h->got.offset; 4413 4414 if (base_got == NULL) 4415 abort (); 4416 4417 if (off == (bfd_vma) -1) 4418 { 4419 /* We can't use h->got.offset here to save state, or 4420 even just remember the offset, as finish_dynamic_symbol 4421 would use that as offset into .got. */ 4422 4423 if (h->plt.offset == (bfd_vma) -1) 4424 abort (); 4425 4426 if (htab->elf.splt != NULL) 4427 { 4428 plt_index = h->plt.offset / plt_entry_size - 1; 4429 off = (plt_index + 3) * GOT_ENTRY_SIZE; 4430 base_got = htab->elf.sgotplt; 4431 } 4432 else 4433 { 4434 plt_index = h->plt.offset / plt_entry_size; 4435 off = plt_index * GOT_ENTRY_SIZE; 4436 base_got = htab->elf.igotplt; 4437 } 4438 4439 if (h->dynindx == -1 4440 || h->forced_local 4441 || info->symbolic) 4442 { 4443 /* This references the local defitionion. We must 4444 initialize this entry in the global offset table. 4445 Since the offset must always be a multiple of 8, 4446 we use the least significant bit to record 4447 whether we have initialized it already. 4448 4449 When doing a dynamic link, we create a .rela.got 4450 relocation entry to initialize the value. This 4451 is done in the finish_dynamic_symbol routine. */ 4452 if ((off & 1) != 0) 4453 off &= ~1; 4454 else 4455 { 4456 bfd_put_64 (output_bfd, relocation, 4457 base_got->contents + off); 4458 /* Note that this is harmless for the GOTPLT64 4459 case, as -1 | 1 still is -1. */ 4460 h->got.offset |= 1; 4461 } 4462 } 4463 } 4464 4465 relocation = (base_got->output_section->vma 4466 + base_got->output_offset + off); 4467 4468 goto do_relocation; 4469 } 4470 4471 if (h->plt.offset == (bfd_vma) -1) 4472 { 4473 /* Handle static pointers of STT_GNU_IFUNC symbols. */ 4474 if (r_type == htab->pointer_r_type 4475 && (input_section->flags & SEC_CODE) == 0) 4476 goto do_ifunc_pointer; 4477 goto bad_ifunc_reloc; 4478 } 4479 4480 /* STT_GNU_IFUNC symbol must go through PLT. */ 4481 if (htab->elf.splt != NULL) 4482 { 4483 if (htab->plt_bnd != NULL) 4484 { 4485 resolved_plt = htab->plt_bnd; 4486 plt_offset = eh->plt_bnd.offset; 4487 } 4488 else 4489 { 4490 resolved_plt = htab->elf.splt; 4491 plt_offset = h->plt.offset; 4492 } 4493 } 4494 else 4495 { 4496 resolved_plt = htab->elf.iplt; 4497 plt_offset = h->plt.offset; 4498 } 4499 4500 relocation = (resolved_plt->output_section->vma 4501 + resolved_plt->output_offset + plt_offset); 4502 4503 switch (r_type) 4504 { 4505 default: 4506bad_ifunc_reloc: 4507 if (h->root.root.string) 4508 name = h->root.root.string; 4509 else 4510 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 4511 NULL); 4512 _bfd_error_handler 4513 /* xgettext:c-format */ 4514 (_("%B: relocation %s against STT_GNU_IFUNC " 4515 "symbol `%s' isn't supported"), input_bfd, 4516 howto->name, name); 4517 bfd_set_error (bfd_error_bad_value); 4518 return FALSE; 4519 4520 case R_X86_64_32S: 4521 if (bfd_link_pic (info)) 4522 abort (); 4523 goto do_relocation; 4524 4525 case R_X86_64_32: 4526 if (ABI_64_P (output_bfd)) 4527 goto do_relocation; 4528 /* FALLTHROUGH */ 4529 case R_X86_64_64: 4530do_ifunc_pointer: 4531 if (rel->r_addend != 0) 4532 { 4533 if (h->root.root.string) 4534 name = h->root.root.string; 4535 else 4536 name = bfd_elf_sym_name (input_bfd, symtab_hdr, 4537 sym, NULL); 4538 _bfd_error_handler 4539 /* xgettext:c-format */ 4540 (_("%B: relocation %s against STT_GNU_IFUNC " 4541 "symbol `%s' has non-zero addend: %d"), 4542 input_bfd, howto->name, name, rel->r_addend); 4543 bfd_set_error (bfd_error_bad_value); 4544 return FALSE; 4545 } 4546 4547 /* Generate dynamic relcoation only when there is a 4548 non-GOT reference in a shared object or there is no 4549 PLT. */ 4550 if ((bfd_link_pic (info) && h->non_got_ref) 4551 || h->plt.offset == (bfd_vma) -1) 4552 { 4553 Elf_Internal_Rela outrel; 4554 asection *sreloc; 4555 4556 /* Need a dynamic relocation to get the real function 4557 address. */ 4558 outrel.r_offset = _bfd_elf_section_offset (output_bfd, 4559 info, 4560 input_section, 4561 rel->r_offset); 4562 if (outrel.r_offset == (bfd_vma) -1 4563 || outrel.r_offset == (bfd_vma) -2) 4564 abort (); 4565 4566 outrel.r_offset += (input_section->output_section->vma 4567 + input_section->output_offset); 4568 4569 if (h->dynindx == -1 4570 || h->forced_local 4571 || bfd_link_executable (info)) 4572 { 4573 /* This symbol is resolved locally. */ 4574 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE); 4575 outrel.r_addend = (h->root.u.def.value 4576 + h->root.u.def.section->output_section->vma 4577 + h->root.u.def.section->output_offset); 4578 } 4579 else 4580 { 4581 outrel.r_info = htab->r_info (h->dynindx, r_type); 4582 outrel.r_addend = 0; 4583 } 4584 4585 /* Dynamic relocations are stored in 4586 1. .rela.ifunc section in PIC object. 4587 2. .rela.got section in dynamic executable. 4588 3. .rela.iplt section in static executable. */ 4589 if (bfd_link_pic (info)) 4590 sreloc = htab->elf.irelifunc; 4591 else if (htab->elf.splt != NULL) 4592 sreloc = htab->elf.srelgot; 4593 else 4594 sreloc = htab->elf.irelplt; 4595 elf_append_rela (output_bfd, sreloc, &outrel); 4596 4597 /* If this reloc is against an external symbol, we 4598 do not want to fiddle with the addend. Otherwise, 4599 we need to include the symbol value so that it 4600 becomes an addend for the dynamic reloc. For an 4601 internal symbol, we have updated addend. */ 4602 continue; 4603 } 4604 /* FALLTHROUGH */ 4605 case R_X86_64_PC32: 4606 case R_X86_64_PC32_BND: 4607 case R_X86_64_PC64: 4608 case R_X86_64_PLT32: 4609 case R_X86_64_PLT32_BND: 4610 goto do_relocation; 4611 } 4612 } 4613 4614 resolved_to_zero = (eh != NULL 4615 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, 4616 eh->has_got_reloc, 4617 eh)); 4618 4619 /* When generating a shared object, the relocations handled here are 4620 copied into the output file to be resolved at run time. */ 4621 switch (r_type) 4622 { 4623 case R_X86_64_GOT32: 4624 case R_X86_64_GOT64: 4625 /* Relocation is to the entry for this symbol in the global 4626 offset table. */ 4627 case R_X86_64_GOTPCREL: 4628 case R_X86_64_GOTPCRELX: 4629 case R_X86_64_REX_GOTPCRELX: 4630 case R_X86_64_GOTPCREL64: 4631 /* Use global offset table entry as symbol value. */ 4632 case R_X86_64_GOTPLT64: 4633 /* This is obsolete and treated the the same as GOT64. */ 4634 base_got = htab->elf.sgot; 4635 4636 if (htab->elf.sgot == NULL) 4637 abort (); 4638 4639 if (h != NULL) 4640 { 4641 bfd_boolean dyn; 4642 4643 off = h->got.offset; 4644 if (h->needs_plt 4645 && h->plt.offset != (bfd_vma)-1 4646 && off == (bfd_vma)-1) 4647 { 4648 /* We can't use h->got.offset here to save 4649 state, or even just remember the offset, as 4650 finish_dynamic_symbol would use that as offset into 4651 .got. */ 4652 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1; 4653 off = (plt_index + 3) * GOT_ENTRY_SIZE; 4654 base_got = htab->elf.sgotplt; 4655 } 4656 4657 dyn = htab->elf.dynamic_sections_created; 4658 4659 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 4660 || (bfd_link_pic (info) 4661 && SYMBOL_REFERENCES_LOCAL (info, h)) 4662 || (ELF_ST_VISIBILITY (h->other) 4663 && h->root.type == bfd_link_hash_undefweak)) 4664 { 4665 /* This is actually a static link, or it is a -Bsymbolic 4666 link and the symbol is defined locally, or the symbol 4667 was forced to be local because of a version file. We 4668 must initialize this entry in the global offset table. 4669 Since the offset must always be a multiple of 8, we 4670 use the least significant bit to record whether we 4671 have initialized it already. 4672 4673 When doing a dynamic link, we create a .rela.got 4674 relocation entry to initialize the value. This is 4675 done in the finish_dynamic_symbol routine. */ 4676 if ((off & 1) != 0) 4677 off &= ~1; 4678 else 4679 { 4680 bfd_put_64 (output_bfd, relocation, 4681 base_got->contents + off); 4682 /* Note that this is harmless for the GOTPLT64 case, 4683 as -1 | 1 still is -1. */ 4684 h->got.offset |= 1; 4685 } 4686 } 4687 else 4688 unresolved_reloc = FALSE; 4689 } 4690 else 4691 { 4692 if (local_got_offsets == NULL) 4693 abort (); 4694 4695 off = local_got_offsets[r_symndx]; 4696 4697 /* The offset must always be a multiple of 8. We use 4698 the least significant bit to record whether we have 4699 already generated the necessary reloc. */ 4700 if ((off & 1) != 0) 4701 off &= ~1; 4702 else 4703 { 4704 bfd_put_64 (output_bfd, relocation, 4705 base_got->contents + off); 4706 4707 if (bfd_link_pic (info)) 4708 { 4709 asection *s; 4710 Elf_Internal_Rela outrel; 4711 4712 /* We need to generate a R_X86_64_RELATIVE reloc 4713 for the dynamic linker. */ 4714 s = htab->elf.srelgot; 4715 if (s == NULL) 4716 abort (); 4717 4718 outrel.r_offset = (base_got->output_section->vma 4719 + base_got->output_offset 4720 + off); 4721 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE); 4722 outrel.r_addend = relocation; 4723 elf_append_rela (output_bfd, s, &outrel); 4724 } 4725 4726 local_got_offsets[r_symndx] |= 1; 4727 } 4728 } 4729 4730 if (off >= (bfd_vma) -2) 4731 abort (); 4732 4733 relocation = base_got->output_section->vma 4734 + base_got->output_offset + off; 4735 if (r_type != R_X86_64_GOTPCREL 4736 && r_type != R_X86_64_GOTPCRELX 4737 && r_type != R_X86_64_REX_GOTPCRELX 4738 && r_type != R_X86_64_GOTPCREL64) 4739 relocation -= htab->elf.sgotplt->output_section->vma 4740 - htab->elf.sgotplt->output_offset; 4741 4742 break; 4743 4744 case R_X86_64_GOTOFF64: 4745 /* Relocation is relative to the start of the global offset 4746 table. */ 4747 4748 /* Check to make sure it isn't a protected function or data 4749 symbol for shared library since it may not be local when 4750 used as function address or with copy relocation. We also 4751 need to make sure that a symbol is referenced locally. */ 4752 if (bfd_link_pic (info) && h) 4753 { 4754 if (!h->def_regular) 4755 { 4756 const char *v; 4757 4758 switch (ELF_ST_VISIBILITY (h->other)) 4759 { 4760 case STV_HIDDEN: 4761 v = _("hidden symbol"); 4762 break; 4763 case STV_INTERNAL: 4764 v = _("internal symbol"); 4765 break; 4766 case STV_PROTECTED: 4767 v = _("protected symbol"); 4768 break; 4769 default: 4770 v = _("symbol"); 4771 break; 4772 } 4773 4774 _bfd_error_handler 4775 /* xgettext:c-format */ 4776 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"), 4777 input_bfd, v, h->root.root.string); 4778 bfd_set_error (bfd_error_bad_value); 4779 return FALSE; 4780 } 4781 else if (!bfd_link_executable (info) 4782 && !SYMBOL_REFERENCES_LOCAL (info, h) 4783 && (h->type == STT_FUNC 4784 || h->type == STT_OBJECT) 4785 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED) 4786 { 4787 _bfd_error_handler 4788 /* xgettext:c-format */ 4789 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"), 4790 input_bfd, 4791 h->type == STT_FUNC ? "function" : "data", 4792 h->root.root.string); 4793 bfd_set_error (bfd_error_bad_value); 4794 return FALSE; 4795 } 4796 } 4797 4798 /* Note that sgot is not involved in this 4799 calculation. We always want the start of .got.plt. If we 4800 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is 4801 permitted by the ABI, we might have to change this 4802 calculation. */ 4803 relocation -= htab->elf.sgotplt->output_section->vma 4804 + htab->elf.sgotplt->output_offset; 4805 break; 4806 4807 case R_X86_64_GOTPC32: 4808 case R_X86_64_GOTPC64: 4809 /* Use global offset table as symbol value. */ 4810 relocation = htab->elf.sgotplt->output_section->vma 4811 + htab->elf.sgotplt->output_offset; 4812 unresolved_reloc = FALSE; 4813 break; 4814 4815 case R_X86_64_PLTOFF64: 4816 /* Relocation is PLT entry relative to GOT. For local 4817 symbols it's the symbol itself relative to GOT. */ 4818 if (h != NULL 4819 /* See PLT32 handling. */ 4820 && (h->plt.offset != (bfd_vma) -1 4821 || eh->plt_got.offset != (bfd_vma) -1) 4822 && htab->elf.splt != NULL) 4823 { 4824 if (eh->plt_got.offset != (bfd_vma) -1) 4825 { 4826 /* Use the GOT PLT. */ 4827 resolved_plt = htab->plt_got; 4828 plt_offset = eh->plt_got.offset; 4829 } 4830 else if (htab->plt_bnd != NULL) 4831 { 4832 resolved_plt = htab->plt_bnd; 4833 plt_offset = eh->plt_bnd.offset; 4834 } 4835 else 4836 { 4837 resolved_plt = htab->elf.splt; 4838 plt_offset = h->plt.offset; 4839 } 4840 4841 relocation = (resolved_plt->output_section->vma 4842 + resolved_plt->output_offset 4843 + plt_offset); 4844 unresolved_reloc = FALSE; 4845 } 4846 4847 relocation -= htab->elf.sgotplt->output_section->vma 4848 + htab->elf.sgotplt->output_offset; 4849 break; 4850 4851 case R_X86_64_PLT32: 4852 case R_X86_64_PLT32_BND: 4853 /* Relocation is to the entry for this symbol in the 4854 procedure linkage table. */ 4855 4856 /* Resolve a PLT32 reloc against a local symbol directly, 4857 without using the procedure linkage table. */ 4858 if (h == NULL) 4859 break; 4860 4861 if ((h->plt.offset == (bfd_vma) -1 4862 && eh->plt_got.offset == (bfd_vma) -1) 4863 || htab->elf.splt == NULL) 4864 { 4865 /* We didn't make a PLT entry for this symbol. This 4866 happens when statically linking PIC code, or when 4867 using -Bsymbolic. */ 4868 break; 4869 } 4870 4871 if (h->plt.offset != (bfd_vma) -1) 4872 { 4873 if (htab->plt_bnd != NULL) 4874 { 4875 resolved_plt = htab->plt_bnd; 4876 plt_offset = eh->plt_bnd.offset; 4877 } 4878 else 4879 { 4880 resolved_plt = htab->elf.splt; 4881 plt_offset = h->plt.offset; 4882 } 4883 } 4884 else 4885 { 4886 /* Use the GOT PLT. */ 4887 resolved_plt = htab->plt_got; 4888 plt_offset = eh->plt_got.offset; 4889 } 4890 4891 relocation = (resolved_plt->output_section->vma 4892 + resolved_plt->output_offset 4893 + plt_offset); 4894 unresolved_reloc = FALSE; 4895 break; 4896 4897 case R_X86_64_SIZE32: 4898 case R_X86_64_SIZE64: 4899 /* Set to symbol size. */ 4900 relocation = st_size; 4901 goto direct; 4902 4903 case R_X86_64_PC8: 4904 case R_X86_64_PC16: 4905 case R_X86_64_PC32: 4906 case R_X86_64_PC32_BND: 4907 /* Don't complain about -fPIC if the symbol is undefined when 4908 building executable unless it is unresolved weak symbol. */ 4909 if ((input_section->flags & SEC_ALLOC) != 0 4910 && (input_section->flags & SEC_READONLY) != 0 4911 && h != NULL 4912 && ((bfd_link_executable (info) 4913 && h->root.type == bfd_link_hash_undefweak 4914 && !resolved_to_zero) 4915 || (bfd_link_pic (info) 4916 && !(bfd_link_pie (info) 4917 && h->root.type == bfd_link_hash_undefined)))) 4918 { 4919 bfd_boolean fail = FALSE; 4920 bfd_boolean branch 4921 = ((r_type == R_X86_64_PC32 4922 || r_type == R_X86_64_PC32_BND) 4923 && is_32bit_relative_branch (contents, rel->r_offset)); 4924 4925 if (SYMBOL_REFERENCES_LOCAL (info, h)) 4926 { 4927 /* Symbol is referenced locally. Make sure it is 4928 defined locally or for a branch. */ 4929 fail = (!(h->def_regular || ELF_COMMON_DEF_P (h)) 4930 && !branch); 4931 } 4932 else if (!(bfd_link_pie (info) 4933 && (h->needs_copy || eh->needs_copy))) 4934 { 4935 /* Symbol doesn't need copy reloc and isn't referenced 4936 locally. We only allow branch to symbol with 4937 non-default visibility. */ 4938 fail = (!branch 4939 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT); 4940 } 4941 4942 if (fail) 4943 return elf_x86_64_need_pic (input_bfd, input_section, 4944 h, NULL, NULL, howto); 4945 } 4946 /* Fall through. */ 4947 4948 case R_X86_64_8: 4949 case R_X86_64_16: 4950 case R_X86_64_32: 4951 case R_X86_64_PC64: 4952 case R_X86_64_64: 4953 /* FIXME: The ABI says the linker should make sure the value is 4954 the same when it's zeroextended to 64 bit. */ 4955 4956direct: 4957 if ((input_section->flags & SEC_ALLOC) == 0) 4958 break; 4959 4960 /* Don't copy a pc-relative relocation into the output file 4961 if the symbol needs copy reloc or the symbol is undefined 4962 when building executable. Copy dynamic function pointer 4963 relocations. Don't generate dynamic relocations against 4964 resolved undefined weak symbols in PIE. */ 4965 if ((bfd_link_pic (info) 4966 && !(bfd_link_pie (info) 4967 && h != NULL 4968 && (h->needs_copy 4969 || eh->needs_copy 4970 || h->root.type == bfd_link_hash_undefined) 4971 && (IS_X86_64_PCREL_TYPE (r_type) 4972 || r_type == R_X86_64_SIZE32 4973 || r_type == R_X86_64_SIZE64)) 4974 && (h == NULL 4975 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4976 && !resolved_to_zero) 4977 || h->root.type != bfd_link_hash_undefweak)) 4978 && ((! IS_X86_64_PCREL_TYPE (r_type) 4979 && r_type != R_X86_64_SIZE32 4980 && r_type != R_X86_64_SIZE64) 4981 || ! SYMBOL_CALLS_LOCAL (info, h))) 4982 || (ELIMINATE_COPY_RELOCS 4983 && !bfd_link_pic (info) 4984 && h != NULL 4985 && h->dynindx != -1 4986 && (!h->non_got_ref 4987 || eh->func_pointer_refcount > 0 4988 || (h->root.type == bfd_link_hash_undefweak 4989 && !resolved_to_zero)) 4990 && ((h->def_dynamic && !h->def_regular) 4991 /* Undefined weak symbol is bound locally when 4992 PIC is false. */ 4993 || h->root.type == bfd_link_hash_undefined))) 4994 { 4995 Elf_Internal_Rela outrel; 4996 bfd_boolean skip, relocate; 4997 asection *sreloc; 4998 4999 /* When generating a shared object, these relocations 5000 are copied into the output file to be resolved at run 5001 time. */ 5002 skip = FALSE; 5003 relocate = FALSE; 5004 5005 outrel.r_offset = 5006 _bfd_elf_section_offset (output_bfd, info, input_section, 5007 rel->r_offset); 5008 if (outrel.r_offset == (bfd_vma) -1) 5009 skip = TRUE; 5010 else if (outrel.r_offset == (bfd_vma) -2) 5011 skip = TRUE, relocate = TRUE; 5012 5013 outrel.r_offset += (input_section->output_section->vma 5014 + input_section->output_offset); 5015 5016 if (skip) 5017 memset (&outrel, 0, sizeof outrel); 5018 5019 /* h->dynindx may be -1 if this symbol was marked to 5020 become local. */ 5021 else if (h != NULL 5022 && h->dynindx != -1 5023 && (IS_X86_64_PCREL_TYPE (r_type) 5024 || !(bfd_link_executable (info) 5025 || SYMBOLIC_BIND (info, h)) 5026 || ! h->def_regular)) 5027 { 5028 outrel.r_info = htab->r_info (h->dynindx, r_type); 5029 outrel.r_addend = rel->r_addend; 5030 } 5031 else 5032 { 5033 /* This symbol is local, or marked to become local. 5034 When relocation overflow check is disabled, we 5035 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */ 5036 if (r_type == htab->pointer_r_type 5037 || (r_type == R_X86_64_32 5038 && info->no_reloc_overflow_check)) 5039 { 5040 relocate = TRUE; 5041 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE); 5042 outrel.r_addend = relocation + rel->r_addend; 5043 } 5044 else if (r_type == R_X86_64_64 5045 && !ABI_64_P (output_bfd)) 5046 { 5047 relocate = TRUE; 5048 outrel.r_info = htab->r_info (0, 5049 R_X86_64_RELATIVE64); 5050 outrel.r_addend = relocation + rel->r_addend; 5051 /* Check addend overflow. */ 5052 if ((outrel.r_addend & 0x80000000) 5053 != (rel->r_addend & 0x80000000)) 5054 { 5055 const char *name; 5056 int addend = rel->r_addend; 5057 if (h && h->root.root.string) 5058 name = h->root.root.string; 5059 else 5060 name = bfd_elf_sym_name (input_bfd, symtab_hdr, 5061 sym, NULL); 5062 if (addend < 0) 5063 _bfd_error_handler 5064 /* xgettext:c-format */ 5065 (_("%B: addend -0x%x in relocation %s against " 5066 "symbol `%s' at 0x%lx in section `%A' is " 5067 "out of range"), 5068 input_bfd, input_section, addend, 5069 howto->name, name, 5070 (unsigned long) rel->r_offset); 5071 else 5072 _bfd_error_handler 5073 /* xgettext:c-format */ 5074 (_("%B: addend 0x%x in relocation %s against " 5075 "symbol `%s' at 0x%lx in section `%A' is " 5076 "out of range"), 5077 input_bfd, input_section, addend, 5078 howto->name, name, 5079 (unsigned long) rel->r_offset); 5080 bfd_set_error (bfd_error_bad_value); 5081 return FALSE; 5082 } 5083 } 5084 else 5085 { 5086 long sindx; 5087 5088 if (bfd_is_abs_section (sec)) 5089 sindx = 0; 5090 else if (sec == NULL || sec->owner == NULL) 5091 { 5092 bfd_set_error (bfd_error_bad_value); 5093 return FALSE; 5094 } 5095 else 5096 { 5097 asection *osec; 5098 5099 /* We are turning this relocation into one 5100 against a section symbol. It would be 5101 proper to subtract the symbol's value, 5102 osec->vma, from the emitted reloc addend, 5103 but ld.so expects buggy relocs. */ 5104 osec = sec->output_section; 5105 sindx = elf_section_data (osec)->dynindx; 5106 if (sindx == 0) 5107 { 5108 asection *oi = htab->elf.text_index_section; 5109 sindx = elf_section_data (oi)->dynindx; 5110 } 5111 BFD_ASSERT (sindx != 0); 5112 } 5113 5114 outrel.r_info = htab->r_info (sindx, r_type); 5115 outrel.r_addend = relocation + rel->r_addend; 5116 } 5117 } 5118 5119 sreloc = elf_section_data (input_section)->sreloc; 5120 5121 if (sreloc == NULL || sreloc->contents == NULL) 5122 { 5123 r = bfd_reloc_notsupported; 5124 goto check_relocation_error; 5125 } 5126 5127 elf_append_rela (output_bfd, sreloc, &outrel); 5128 5129 /* If this reloc is against an external symbol, we do 5130 not want to fiddle with the addend. Otherwise, we 5131 need to include the symbol value so that it becomes 5132 an addend for the dynamic reloc. */ 5133 if (! relocate) 5134 continue; 5135 } 5136 5137 break; 5138 5139 case R_X86_64_TLSGD: 5140 case R_X86_64_GOTPC32_TLSDESC: 5141 case R_X86_64_TLSDESC_CALL: 5142 case R_X86_64_GOTTPOFF: 5143 tls_type = GOT_UNKNOWN; 5144 if (h == NULL && local_got_offsets) 5145 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx]; 5146 else if (h != NULL) 5147 tls_type = elf_x86_64_hash_entry (h)->tls_type; 5148 5149 if (! elf_x86_64_tls_transition (info, input_bfd, 5150 input_section, contents, 5151 symtab_hdr, sym_hashes, 5152 &r_type, tls_type, rel, 5153 relend, h, r_symndx, TRUE)) 5154 return FALSE; 5155 5156 if (r_type == R_X86_64_TPOFF32) 5157 { 5158 bfd_vma roff = rel->r_offset; 5159 5160 BFD_ASSERT (! unresolved_reloc); 5161 5162 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD) 5163 { 5164 /* GD->LE transition. For 64bit, change 5165 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 5166 .word 0x6666; rex64; call __tls_get_addr@PLT 5167 or 5168 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 5169 .byte 0x66; rex64 5170 call *__tls_get_addr@GOTPCREL(%rip) 5171 which may be converted to 5172 addr32 call __tls_get_addr 5173 into: 5174 movq %fs:0, %rax 5175 leaq foo@tpoff(%rax), %rax 5176 For 32bit, change 5177 leaq foo@tlsgd(%rip), %rdi 5178 .word 0x6666; rex64; call __tls_get_addr@PLT 5179 or 5180 leaq foo@tlsgd(%rip), %rdi 5181 .byte 0x66; rex64 5182 call *__tls_get_addr@GOTPCREL(%rip) 5183 which may be converted to 5184 addr32 call __tls_get_addr 5185 into: 5186 movl %fs:0, %eax 5187 leaq foo@tpoff(%rax), %rax 5188 For largepic, change: 5189 leaq foo@tlsgd(%rip), %rdi 5190 movabsq $__tls_get_addr@pltoff, %rax 5191 addq %r15, %rax 5192 call *%rax 5193 into: 5194 movq %fs:0, %rax 5195 leaq foo@tpoff(%rax), %rax 5196 nopw 0x0(%rax,%rax,1) */ 5197 int largepic = 0; 5198 if (ABI_64_P (output_bfd)) 5199 { 5200 if (contents[roff + 5] == 0xb8) 5201 { 5202 memcpy (contents + roff - 3, 5203 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80" 5204 "\0\0\0\0\x66\x0f\x1f\x44\0", 22); 5205 largepic = 1; 5206 } 5207 else 5208 memcpy (contents + roff - 4, 5209 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", 5210 16); 5211 } 5212 else 5213 memcpy (contents + roff - 3, 5214 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", 5215 15); 5216 bfd_put_32 (output_bfd, 5217 elf_x86_64_tpoff (info, relocation), 5218 contents + roff + 8 + largepic); 5219 /* Skip R_X86_64_PC32, R_X86_64_PLT32, 5220 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */ 5221 rel++; 5222 wrel++; 5223 continue; 5224 } 5225 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC) 5226 { 5227 /* GDesc -> LE transition. 5228 It's originally something like: 5229 leaq x@tlsdesc(%rip), %rax 5230 5231 Change it to: 5232 movl $x@tpoff, %rax. */ 5233 5234 unsigned int val, type; 5235 5236 type = bfd_get_8 (input_bfd, contents + roff - 3); 5237 val = bfd_get_8 (input_bfd, contents + roff - 1); 5238 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1), 5239 contents + roff - 3); 5240 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2); 5241 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7), 5242 contents + roff - 1); 5243 bfd_put_32 (output_bfd, 5244 elf_x86_64_tpoff (info, relocation), 5245 contents + roff); 5246 continue; 5247 } 5248 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL) 5249 { 5250 /* GDesc -> LE transition. 5251 It's originally: 5252 call *(%rax) 5253 Turn it into: 5254 xchg %ax,%ax. */ 5255 bfd_put_8 (output_bfd, 0x66, contents + roff); 5256 bfd_put_8 (output_bfd, 0x90, contents + roff + 1); 5257 continue; 5258 } 5259 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF) 5260 { 5261 /* IE->LE transition: 5262 For 64bit, originally it can be one of: 5263 movq foo@gottpoff(%rip), %reg 5264 addq foo@gottpoff(%rip), %reg 5265 We change it into: 5266 movq $foo, %reg 5267 leaq foo(%reg), %reg 5268 addq $foo, %reg. 5269 For 32bit, originally it can be one of: 5270 movq foo@gottpoff(%rip), %reg 5271 addl foo@gottpoff(%rip), %reg 5272 We change it into: 5273 movq $foo, %reg 5274 leal foo(%reg), %reg 5275 addl $foo, %reg. */ 5276 5277 unsigned int val, type, reg; 5278 5279 if (roff >= 3) 5280 val = bfd_get_8 (input_bfd, contents + roff - 3); 5281 else 5282 val = 0; 5283 type = bfd_get_8 (input_bfd, contents + roff - 2); 5284 reg = bfd_get_8 (input_bfd, contents + roff - 1); 5285 reg >>= 3; 5286 if (type == 0x8b) 5287 { 5288 /* movq */ 5289 if (val == 0x4c) 5290 bfd_put_8 (output_bfd, 0x49, 5291 contents + roff - 3); 5292 else if (!ABI_64_P (output_bfd) && val == 0x44) 5293 bfd_put_8 (output_bfd, 0x41, 5294 contents + roff - 3); 5295 bfd_put_8 (output_bfd, 0xc7, 5296 contents + roff - 2); 5297 bfd_put_8 (output_bfd, 0xc0 | reg, 5298 contents + roff - 1); 5299 } 5300 else if (reg == 4) 5301 { 5302 /* addq/addl -> addq/addl - addressing with %rsp/%r12 5303 is special */ 5304 if (val == 0x4c) 5305 bfd_put_8 (output_bfd, 0x49, 5306 contents + roff - 3); 5307 else if (!ABI_64_P (output_bfd) && val == 0x44) 5308 bfd_put_8 (output_bfd, 0x41, 5309 contents + roff - 3); 5310 bfd_put_8 (output_bfd, 0x81, 5311 contents + roff - 2); 5312 bfd_put_8 (output_bfd, 0xc0 | reg, 5313 contents + roff - 1); 5314 } 5315 else 5316 { 5317 /* addq/addl -> leaq/leal */ 5318 if (val == 0x4c) 5319 bfd_put_8 (output_bfd, 0x4d, 5320 contents + roff - 3); 5321 else if (!ABI_64_P (output_bfd) && val == 0x44) 5322 bfd_put_8 (output_bfd, 0x45, 5323 contents + roff - 3); 5324 bfd_put_8 (output_bfd, 0x8d, 5325 contents + roff - 2); 5326 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3), 5327 contents + roff - 1); 5328 } 5329 bfd_put_32 (output_bfd, 5330 elf_x86_64_tpoff (info, relocation), 5331 contents + roff); 5332 continue; 5333 } 5334 else 5335 BFD_ASSERT (FALSE); 5336 } 5337 5338 if (htab->elf.sgot == NULL) 5339 abort (); 5340 5341 if (h != NULL) 5342 { 5343 off = h->got.offset; 5344 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got; 5345 } 5346 else 5347 { 5348 if (local_got_offsets == NULL) 5349 abort (); 5350 5351 off = local_got_offsets[r_symndx]; 5352 offplt = local_tlsdesc_gotents[r_symndx]; 5353 } 5354 5355 if ((off & 1) != 0) 5356 off &= ~1; 5357 else 5358 { 5359 Elf_Internal_Rela outrel; 5360 int dr_type, indx; 5361 asection *sreloc; 5362 5363 if (htab->elf.srelgot == NULL) 5364 abort (); 5365 5366 indx = h && h->dynindx != -1 ? h->dynindx : 0; 5367 5368 if (GOT_TLS_GDESC_P (tls_type)) 5369 { 5370 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC); 5371 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt 5372 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size); 5373 outrel.r_offset = (htab->elf.sgotplt->output_section->vma 5374 + htab->elf.sgotplt->output_offset 5375 + offplt 5376 + htab->sgotplt_jump_table_size); 5377 sreloc = htab->elf.srelplt; 5378 if (indx == 0) 5379 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info); 5380 else 5381 outrel.r_addend = 0; 5382 elf_append_rela (output_bfd, sreloc, &outrel); 5383 } 5384 5385 sreloc = htab->elf.srelgot; 5386 5387 outrel.r_offset = (htab->elf.sgot->output_section->vma 5388 + htab->elf.sgot->output_offset + off); 5389 5390 if (GOT_TLS_GD_P (tls_type)) 5391 dr_type = R_X86_64_DTPMOD64; 5392 else if (GOT_TLS_GDESC_P (tls_type)) 5393 goto dr_done; 5394 else 5395 dr_type = R_X86_64_TPOFF64; 5396 5397 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off); 5398 outrel.r_addend = 0; 5399 if ((dr_type == R_X86_64_TPOFF64 5400 || dr_type == R_X86_64_TLSDESC) && indx == 0) 5401 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info); 5402 outrel.r_info = htab->r_info (indx, dr_type); 5403 5404 elf_append_rela (output_bfd, sreloc, &outrel); 5405 5406 if (GOT_TLS_GD_P (tls_type)) 5407 { 5408 if (indx == 0) 5409 { 5410 BFD_ASSERT (! unresolved_reloc); 5411 bfd_put_64 (output_bfd, 5412 relocation - elf_x86_64_dtpoff_base (info), 5413 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE); 5414 } 5415 else 5416 { 5417 bfd_put_64 (output_bfd, 0, 5418 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE); 5419 outrel.r_info = htab->r_info (indx, 5420 R_X86_64_DTPOFF64); 5421 outrel.r_offset += GOT_ENTRY_SIZE; 5422 elf_append_rela (output_bfd, sreloc, 5423 &outrel); 5424 } 5425 } 5426 5427 dr_done: 5428 if (h != NULL) 5429 h->got.offset |= 1; 5430 else 5431 local_got_offsets[r_symndx] |= 1; 5432 } 5433 5434 if (off >= (bfd_vma) -2 5435 && ! GOT_TLS_GDESC_P (tls_type)) 5436 abort (); 5437 if (r_type == ELF32_R_TYPE (rel->r_info)) 5438 { 5439 if (r_type == R_X86_64_GOTPC32_TLSDESC 5440 || r_type == R_X86_64_TLSDESC_CALL) 5441 relocation = htab->elf.sgotplt->output_section->vma 5442 + htab->elf.sgotplt->output_offset 5443 + offplt + htab->sgotplt_jump_table_size; 5444 else 5445 relocation = htab->elf.sgot->output_section->vma 5446 + htab->elf.sgot->output_offset + off; 5447 unresolved_reloc = FALSE; 5448 } 5449 else 5450 { 5451 bfd_vma roff = rel->r_offset; 5452 5453 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD) 5454 { 5455 /* GD->IE transition. For 64bit, change 5456 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 5457 .word 0x6666; rex64; call __tls_get_addr@PLT 5458 or 5459 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 5460 .byte 0x66; rex64 5461 call *__tls_get_addr@GOTPCREL(%rip 5462 which may be converted to 5463 addr32 call __tls_get_addr 5464 into: 5465 movq %fs:0, %rax 5466 addq foo@gottpoff(%rip), %rax 5467 For 32bit, change 5468 leaq foo@tlsgd(%rip), %rdi 5469 .word 0x6666; rex64; call __tls_get_addr@PLT 5470 or 5471 leaq foo@tlsgd(%rip), %rdi 5472 .byte 0x66; rex64; 5473 call *__tls_get_addr@GOTPCREL(%rip) 5474 which may be converted to 5475 addr32 call __tls_get_addr 5476 into: 5477 movl %fs:0, %eax 5478 addq foo@gottpoff(%rip), %rax 5479 For largepic, change: 5480 leaq foo@tlsgd(%rip), %rdi 5481 movabsq $__tls_get_addr@pltoff, %rax 5482 addq %r15, %rax 5483 call *%rax 5484 into: 5485 movq %fs:0, %rax 5486 addq foo@gottpoff(%rax), %rax 5487 nopw 0x0(%rax,%rax,1) */ 5488 int largepic = 0; 5489 if (ABI_64_P (output_bfd)) 5490 { 5491 if (contents[roff + 5] == 0xb8) 5492 { 5493 memcpy (contents + roff - 3, 5494 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05" 5495 "\0\0\0\0\x66\x0f\x1f\x44\0", 22); 5496 largepic = 1; 5497 } 5498 else 5499 memcpy (contents + roff - 4, 5500 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", 5501 16); 5502 } 5503 else 5504 memcpy (contents + roff - 3, 5505 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", 5506 15); 5507 5508 relocation = (htab->elf.sgot->output_section->vma 5509 + htab->elf.sgot->output_offset + off 5510 - roff 5511 - largepic 5512 - input_section->output_section->vma 5513 - input_section->output_offset 5514 - 12); 5515 bfd_put_32 (output_bfd, relocation, 5516 contents + roff + 8 + largepic); 5517 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */ 5518 rel++; 5519 wrel++; 5520 continue; 5521 } 5522 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC) 5523 { 5524 /* GDesc -> IE transition. 5525 It's originally something like: 5526 leaq x@tlsdesc(%rip), %rax 5527 5528 Change it to: 5529 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */ 5530 5531 /* Now modify the instruction as appropriate. To 5532 turn a leaq into a movq in the form we use it, it 5533 suffices to change the second byte from 0x8d to 5534 0x8b. */ 5535 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2); 5536 5537 bfd_put_32 (output_bfd, 5538 htab->elf.sgot->output_section->vma 5539 + htab->elf.sgot->output_offset + off 5540 - rel->r_offset 5541 - input_section->output_section->vma 5542 - input_section->output_offset 5543 - 4, 5544 contents + roff); 5545 continue; 5546 } 5547 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL) 5548 { 5549 /* GDesc -> IE transition. 5550 It's originally: 5551 call *(%rax) 5552 5553 Change it to: 5554 xchg %ax, %ax. */ 5555 5556 bfd_put_8 (output_bfd, 0x66, contents + roff); 5557 bfd_put_8 (output_bfd, 0x90, contents + roff + 1); 5558 continue; 5559 } 5560 else 5561 BFD_ASSERT (FALSE); 5562 } 5563 break; 5564 5565 case R_X86_64_TLSLD: 5566 if (! elf_x86_64_tls_transition (info, input_bfd, 5567 input_section, contents, 5568 symtab_hdr, sym_hashes, 5569 &r_type, GOT_UNKNOWN, rel, 5570 relend, h, r_symndx, TRUE)) 5571 return FALSE; 5572 5573 if (r_type != R_X86_64_TLSLD) 5574 { 5575 /* LD->LE transition: 5576 leaq foo@tlsld(%rip), %rdi 5577 call __tls_get_addr@PLT 5578 For 64bit, we change it into: 5579 .word 0x6666; .byte 0x66; movq %fs:0, %rax 5580 For 32bit, we change it into: 5581 nopl 0x0(%rax); movl %fs:0, %eax 5582 Or 5583 leaq foo@tlsld(%rip), %rdi; 5584 call *__tls_get_addr@GOTPCREL(%rip) 5585 which may be converted to 5586 addr32 call __tls_get_addr 5587 For 64bit, we change it into: 5588 .word 0x6666; .word 0x6666; movq %fs:0, %rax 5589 For 32bit, we change it into: 5590 nopw 0x0(%rax); movl %fs:0, %eax 5591 For largepic, change: 5592 leaq foo@tlsgd(%rip), %rdi 5593 movabsq $__tls_get_addr@pltoff, %rax 5594 addq %rbx, %rax 5595 call *%rax 5596 into 5597 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1) 5598 movq %fs:0, %eax */ 5599 5600 BFD_ASSERT (r_type == R_X86_64_TPOFF32); 5601 if (ABI_64_P (output_bfd)) 5602 { 5603 if (contents[rel->r_offset + 5] == 0xb8) 5604 memcpy (contents + rel->r_offset - 3, 5605 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0" 5606 "\x64\x48\x8b\x04\x25\0\0\0", 22); 5607 else if (contents[rel->r_offset + 4] == 0xff 5608 || contents[rel->r_offset + 4] == 0x67) 5609 memcpy (contents + rel->r_offset - 3, 5610 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 5611 13); 5612 else 5613 memcpy (contents + rel->r_offset - 3, 5614 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12); 5615 } 5616 else 5617 { 5618 if (contents[rel->r_offset + 4] == 0xff) 5619 memcpy (contents + rel->r_offset - 3, 5620 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 5621 13); 5622 else 5623 memcpy (contents + rel->r_offset - 3, 5624 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12); 5625 } 5626 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX 5627 and R_X86_64_PLTOFF64. */ 5628 rel++; 5629 wrel++; 5630 continue; 5631 } 5632 5633 if (htab->elf.sgot == NULL) 5634 abort (); 5635 5636 off = htab->tls_ld_got.offset; 5637 if (off & 1) 5638 off &= ~1; 5639 else 5640 { 5641 Elf_Internal_Rela outrel; 5642 5643 if (htab->elf.srelgot == NULL) 5644 abort (); 5645 5646 outrel.r_offset = (htab->elf.sgot->output_section->vma 5647 + htab->elf.sgot->output_offset + off); 5648 5649 bfd_put_64 (output_bfd, 0, 5650 htab->elf.sgot->contents + off); 5651 bfd_put_64 (output_bfd, 0, 5652 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE); 5653 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64); 5654 outrel.r_addend = 0; 5655 elf_append_rela (output_bfd, htab->elf.srelgot, 5656 &outrel); 5657 htab->tls_ld_got.offset |= 1; 5658 } 5659 relocation = htab->elf.sgot->output_section->vma 5660 + htab->elf.sgot->output_offset + off; 5661 unresolved_reloc = FALSE; 5662 break; 5663 5664 case R_X86_64_DTPOFF32: 5665 if (!bfd_link_executable (info) 5666 || (input_section->flags & SEC_CODE) == 0) 5667 relocation -= elf_x86_64_dtpoff_base (info); 5668 else 5669 relocation = elf_x86_64_tpoff (info, relocation); 5670 break; 5671 5672 case R_X86_64_TPOFF32: 5673 case R_X86_64_TPOFF64: 5674 BFD_ASSERT (bfd_link_executable (info)); 5675 relocation = elf_x86_64_tpoff (info, relocation); 5676 break; 5677 5678 case R_X86_64_DTPOFF64: 5679 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0); 5680 relocation -= elf_x86_64_dtpoff_base (info); 5681 break; 5682 5683 default: 5684 break; 5685 } 5686 5687 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 5688 because such sections are not SEC_ALLOC and thus ld.so will 5689 not process them. */ 5690 if (unresolved_reloc 5691 && !((input_section->flags & SEC_DEBUGGING) != 0 5692 && h->def_dynamic) 5693 && _bfd_elf_section_offset (output_bfd, info, input_section, 5694 rel->r_offset) != (bfd_vma) -1) 5695 { 5696 _bfd_error_handler 5697 /* xgettext:c-format */ 5698 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 5699 input_bfd, 5700 input_section, 5701 (long) rel->r_offset, 5702 howto->name, 5703 h->root.root.string); 5704 return FALSE; 5705 } 5706 5707do_relocation: 5708 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 5709 contents, rel->r_offset, 5710 relocation, rel->r_addend); 5711 5712check_relocation_error: 5713 if (r != bfd_reloc_ok) 5714 { 5715 const char *name; 5716 5717 if (h != NULL) 5718 name = h->root.root.string; 5719 else 5720 { 5721 name = bfd_elf_string_from_elf_section (input_bfd, 5722 symtab_hdr->sh_link, 5723 sym->st_name); 5724 if (name == NULL) 5725 return FALSE; 5726 if (*name == '\0') 5727 name = bfd_section_name (input_bfd, sec); 5728 } 5729 5730 if (r == bfd_reloc_overflow) 5731 (*info->callbacks->reloc_overflow) 5732 (info, (h ? &h->root : NULL), name, howto->name, 5733 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 5734 else 5735 { 5736 _bfd_error_handler 5737 /* xgettext:c-format */ 5738 (_("%B(%A+0x%lx): reloc against `%s': error %d"), 5739 input_bfd, input_section, 5740 (long) rel->r_offset, name, (int) r); 5741 return FALSE; 5742 } 5743 } 5744 5745 if (wrel != rel) 5746 *wrel = *rel; 5747 } 5748 5749 if (wrel != rel) 5750 { 5751 Elf_Internal_Shdr *rel_hdr; 5752 size_t deleted = rel - wrel; 5753 5754 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); 5755 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 5756 if (rel_hdr->sh_size == 0) 5757 { 5758 /* It is too late to remove an empty reloc section. Leave 5759 one NONE reloc. 5760 ??? What is wrong with an empty section??? */ 5761 rel_hdr->sh_size = rel_hdr->sh_entsize; 5762 deleted -= 1; 5763 } 5764 rel_hdr = _bfd_elf_single_rel_hdr (input_section); 5765 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 5766 input_section->reloc_count -= deleted; 5767 } 5768 5769 return TRUE; 5770} 5771 5772/* Finish up dynamic symbol handling. We set the contents of various 5773 dynamic sections here. */ 5774 5775static bfd_boolean 5776elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, 5777 struct bfd_link_info *info, 5778 struct elf_link_hash_entry *h, 5779 Elf_Internal_Sym *sym) 5780{ 5781 struct elf_x86_64_link_hash_table *htab; 5782 const struct elf_x86_64_backend_data *abed; 5783 bfd_boolean use_plt_bnd; 5784 struct elf_x86_64_link_hash_entry *eh; 5785 bfd_boolean local_undefweak; 5786 5787 htab = elf_x86_64_hash_table (info); 5788 if (htab == NULL) 5789 return FALSE; 5790 5791 /* Use MPX backend data in case of BND relocation. Use .plt_bnd 5792 section only if there is .plt section. */ 5793 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL; 5794 abed = (use_plt_bnd 5795 ? &elf_x86_64_bnd_arch_bed 5796 : get_elf_x86_64_backend_data (output_bfd)); 5797 5798 eh = (struct elf_x86_64_link_hash_entry *) h; 5799 5800 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for 5801 resolved undefined weak symbols in executable so that their 5802 references have value 0 at run-time. */ 5803 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, 5804 eh->has_got_reloc, 5805 eh); 5806 5807 if (h->plt.offset != (bfd_vma) -1) 5808 { 5809 bfd_vma plt_index; 5810 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset; 5811 bfd_vma plt_plt_insn_end, plt_got_insn_size; 5812 Elf_Internal_Rela rela; 5813 bfd_byte *loc; 5814 asection *plt, *gotplt, *relplt, *resolved_plt; 5815 const struct elf_backend_data *bed; 5816 bfd_vma plt_got_pcrel_offset; 5817 5818 /* When building a static executable, use .iplt, .igot.plt and 5819 .rela.iplt sections for STT_GNU_IFUNC symbols. */ 5820 if (htab->elf.splt != NULL) 5821 { 5822 plt = htab->elf.splt; 5823 gotplt = htab->elf.sgotplt; 5824 relplt = htab->elf.srelplt; 5825 } 5826 else 5827 { 5828 plt = htab->elf.iplt; 5829 gotplt = htab->elf.igotplt; 5830 relplt = htab->elf.irelplt; 5831 } 5832 5833 /* This symbol has an entry in the procedure linkage table. Set 5834 it up. */ 5835 if ((h->dynindx == -1 5836 && !local_undefweak 5837 && !((h->forced_local || bfd_link_executable (info)) 5838 && h->def_regular 5839 && h->type == STT_GNU_IFUNC)) 5840 || plt == NULL 5841 || gotplt == NULL 5842 || relplt == NULL) 5843 abort (); 5844 5845 /* Get the index in the procedure linkage table which 5846 corresponds to this symbol. This is the index of this symbol 5847 in all the symbols for which we are making plt entries. The 5848 first entry in the procedure linkage table is reserved. 5849 5850 Get the offset into the .got table of the entry that 5851 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE 5852 bytes. The first three are reserved for the dynamic linker. 5853 5854 For static executables, we don't reserve anything. */ 5855 5856 if (plt == htab->elf.splt) 5857 { 5858 got_offset = h->plt.offset / abed->plt_entry_size - 1; 5859 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE; 5860 } 5861 else 5862 { 5863 got_offset = h->plt.offset / abed->plt_entry_size; 5864 got_offset = got_offset * GOT_ENTRY_SIZE; 5865 } 5866 5867 plt_plt_insn_end = abed->plt_plt_insn_end; 5868 plt_plt_offset = abed->plt_plt_offset; 5869 plt_got_insn_size = abed->plt_got_insn_size; 5870 plt_got_offset = abed->plt_got_offset; 5871 if (use_plt_bnd) 5872 { 5873 /* Use the second PLT with BND relocations. */ 5874 const bfd_byte *plt_entry, *plt2_entry; 5875 5876 if (eh->has_bnd_reloc) 5877 { 5878 plt_entry = elf_x86_64_bnd_plt_entry; 5879 plt2_entry = elf_x86_64_bnd_plt2_entry; 5880 } 5881 else 5882 { 5883 plt_entry = elf_x86_64_legacy_plt_entry; 5884 plt2_entry = elf_x86_64_legacy_plt2_entry; 5885 5886 /* Subtract 1 since there is no BND prefix. */ 5887 plt_plt_insn_end -= 1; 5888 plt_plt_offset -= 1; 5889 plt_got_insn_size -= 1; 5890 plt_got_offset -= 1; 5891 } 5892 5893 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry) 5894 == sizeof (elf_x86_64_legacy_plt_entry)); 5895 5896 /* Fill in the entry in the procedure linkage table. */ 5897 memcpy (plt->contents + h->plt.offset, 5898 plt_entry, sizeof (elf_x86_64_legacy_plt_entry)); 5899 /* Fill in the entry in the second PLT. */ 5900 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset, 5901 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry)); 5902 5903 resolved_plt = htab->plt_bnd; 5904 plt_offset = eh->plt_bnd.offset; 5905 } 5906 else 5907 { 5908 /* Fill in the entry in the procedure linkage table. */ 5909 memcpy (plt->contents + h->plt.offset, abed->plt_entry, 5910 abed->plt_entry_size); 5911 5912 resolved_plt = plt; 5913 plt_offset = h->plt.offset; 5914 } 5915 5916 /* Insert the relocation positions of the plt section. */ 5917 5918 /* Put offset the PC-relative instruction referring to the GOT entry, 5919 subtracting the size of that instruction. */ 5920 plt_got_pcrel_offset = (gotplt->output_section->vma 5921 + gotplt->output_offset 5922 + got_offset 5923 - resolved_plt->output_section->vma 5924 - resolved_plt->output_offset 5925 - plt_offset 5926 - plt_got_insn_size); 5927 5928 /* Check PC-relative offset overflow in PLT entry. */ 5929 if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff) 5930 /* xgettext:c-format */ 5931 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"), 5932 output_bfd, h->root.root.string); 5933 5934 bfd_put_32 (output_bfd, plt_got_pcrel_offset, 5935 resolved_plt->contents + plt_offset + plt_got_offset); 5936 5937 /* Fill in the entry in the global offset table, initially this 5938 points to the second part of the PLT entry. Leave the entry 5939 as zero for undefined weak symbol in PIE. No PLT relocation 5940 against undefined weak symbol in PIE. */ 5941 if (!local_undefweak) 5942 { 5943 bfd_put_64 (output_bfd, (plt->output_section->vma 5944 + plt->output_offset 5945 + h->plt.offset 5946 + abed->plt_lazy_offset), 5947 gotplt->contents + got_offset); 5948 5949 /* Fill in the entry in the .rela.plt section. */ 5950 rela.r_offset = (gotplt->output_section->vma 5951 + gotplt->output_offset 5952 + got_offset); 5953 if (h->dynindx == -1 5954 || ((bfd_link_executable (info) 5955 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 5956 && h->def_regular 5957 && h->type == STT_GNU_IFUNC)) 5958 { 5959 /* If an STT_GNU_IFUNC symbol is locally defined, generate 5960 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */ 5961 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE); 5962 rela.r_addend = (h->root.u.def.value 5963 + h->root.u.def.section->output_section->vma 5964 + h->root.u.def.section->output_offset); 5965 /* R_X86_64_IRELATIVE comes last. */ 5966 plt_index = htab->next_irelative_index--; 5967 } 5968 else 5969 { 5970 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT); 5971 rela.r_addend = 0; 5972 plt_index = htab->next_jump_slot_index++; 5973 } 5974 5975 /* Don't fill PLT entry for static executables. */ 5976 if (plt == htab->elf.splt) 5977 { 5978 bfd_vma plt0_offset = h->plt.offset + plt_plt_insn_end; 5979 5980 /* Put relocation index. */ 5981 bfd_put_32 (output_bfd, plt_index, 5982 (plt->contents + h->plt.offset 5983 + abed->plt_reloc_offset)); 5984 5985 /* Put offset for jmp .PLT0 and check for overflow. We don't 5986 check relocation index for overflow since branch displacement 5987 will overflow first. */ 5988 if (plt0_offset > 0x80000000) 5989 /* xgettext:c-format */ 5990 info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"), 5991 output_bfd, h->root.root.string); 5992 bfd_put_32 (output_bfd, - plt0_offset, 5993 plt->contents + h->plt.offset + plt_plt_offset); 5994 } 5995 5996 bed = get_elf_backend_data (output_bfd); 5997 loc = relplt->contents + plt_index * bed->s->sizeof_rela; 5998 bed->s->swap_reloca_out (output_bfd, &rela, loc); 5999 } 6000 } 6001 else if (eh->plt_got.offset != (bfd_vma) -1) 6002 { 6003 bfd_vma got_offset, plt_offset, plt_got_offset, plt_got_insn_size; 6004 asection *plt, *got; 6005 bfd_boolean got_after_plt; 6006 int32_t got_pcrel_offset; 6007 const bfd_byte *got_plt_entry; 6008 6009 /* Set the entry in the GOT procedure linkage table. */ 6010 plt = htab->plt_got; 6011 got = htab->elf.sgot; 6012 got_offset = h->got.offset; 6013 6014 if (got_offset == (bfd_vma) -1 6015 || h->type == STT_GNU_IFUNC 6016 || plt == NULL 6017 || got == NULL) 6018 abort (); 6019 6020 /* Use the second PLT entry template for the GOT PLT since they 6021 are the identical. */ 6022 plt_got_insn_size = elf_x86_64_bnd_arch_bed.plt_got_insn_size; 6023 plt_got_offset = elf_x86_64_bnd_arch_bed.plt_got_offset; 6024 if (eh->has_bnd_reloc) 6025 got_plt_entry = elf_x86_64_bnd_plt2_entry; 6026 else 6027 { 6028 got_plt_entry = elf_x86_64_legacy_plt2_entry; 6029 6030 /* Subtract 1 since there is no BND prefix. */ 6031 plt_got_insn_size -= 1; 6032 plt_got_offset -= 1; 6033 } 6034 6035 /* Fill in the entry in the GOT procedure linkage table. */ 6036 plt_offset = eh->plt_got.offset; 6037 memcpy (plt->contents + plt_offset, 6038 got_plt_entry, sizeof (elf_x86_64_legacy_plt2_entry)); 6039 6040 /* Put offset the PC-relative instruction referring to the GOT 6041 entry, subtracting the size of that instruction. */ 6042 got_pcrel_offset = (got->output_section->vma 6043 + got->output_offset 6044 + got_offset 6045 - plt->output_section->vma 6046 - plt->output_offset 6047 - plt_offset 6048 - plt_got_insn_size); 6049 6050 /* Check PC-relative offset overflow in GOT PLT entry. */ 6051 got_after_plt = got->output_section->vma > plt->output_section->vma; 6052 if ((got_after_plt && got_pcrel_offset < 0) 6053 || (!got_after_plt && got_pcrel_offset > 0)) 6054 /* xgettext:c-format */ 6055 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"), 6056 output_bfd, h->root.root.string); 6057 6058 bfd_put_32 (output_bfd, got_pcrel_offset, 6059 plt->contents + plt_offset + plt_got_offset); 6060 } 6061 6062 if (!local_undefweak 6063 && !h->def_regular 6064 && (h->plt.offset != (bfd_vma) -1 6065 || eh->plt_got.offset != (bfd_vma) -1)) 6066 { 6067 /* Mark the symbol as undefined, rather than as defined in 6068 the .plt section. Leave the value if there were any 6069 relocations where pointer equality matters (this is a clue 6070 for the dynamic linker, to make function pointer 6071 comparisons work between an application and shared 6072 library), otherwise set it to zero. If a function is only 6073 called from a binary, there is no need to slow down 6074 shared libraries because of that. */ 6075 sym->st_shndx = SHN_UNDEF; 6076 if (!h->pointer_equality_needed) 6077 sym->st_value = 0; 6078 } 6079 6080 /* Don't generate dynamic GOT relocation against undefined weak 6081 symbol in executable. */ 6082 if (h->got.offset != (bfd_vma) -1 6083 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type) 6084 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE 6085 && !local_undefweak) 6086 { 6087 Elf_Internal_Rela rela; 6088 asection *relgot = htab->elf.srelgot; 6089 6090 /* This symbol has an entry in the global offset table. Set it 6091 up. */ 6092 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL) 6093 abort (); 6094 6095 rela.r_offset = (htab->elf.sgot->output_section->vma 6096 + htab->elf.sgot->output_offset 6097 + (h->got.offset &~ (bfd_vma) 1)); 6098 6099 /* If this is a static link, or it is a -Bsymbolic link and the 6100 symbol is defined locally or was forced to be local because 6101 of a version file, we just want to emit a RELATIVE reloc. 6102 The entry in the global offset table will already have been 6103 initialized in the relocate_section function. */ 6104 if (h->def_regular 6105 && h->type == STT_GNU_IFUNC) 6106 { 6107 if (h->plt.offset == (bfd_vma) -1) 6108 { 6109 /* STT_GNU_IFUNC is referenced without PLT. */ 6110 if (htab->elf.splt == NULL) 6111 { 6112 /* use .rel[a].iplt section to store .got relocations 6113 in static executable. */ 6114 relgot = htab->elf.irelplt; 6115 } 6116 if (SYMBOL_REFERENCES_LOCAL (info, h)) 6117 { 6118 rela.r_info = htab->r_info (0, 6119 R_X86_64_IRELATIVE); 6120 rela.r_addend = (h->root.u.def.value 6121 + h->root.u.def.section->output_section->vma 6122 + h->root.u.def.section->output_offset); 6123 } 6124 else 6125 goto do_glob_dat; 6126 } 6127 else if (bfd_link_pic (info)) 6128 { 6129 /* Generate R_X86_64_GLOB_DAT. */ 6130 goto do_glob_dat; 6131 } 6132 else 6133 { 6134 asection *plt; 6135 6136 if (!h->pointer_equality_needed) 6137 abort (); 6138 6139 /* For non-shared object, we can't use .got.plt, which 6140 contains the real function addres if we need pointer 6141 equality. We load the GOT entry with the PLT entry. */ 6142 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt; 6143 bfd_put_64 (output_bfd, (plt->output_section->vma 6144 + plt->output_offset 6145 + h->plt.offset), 6146 htab->elf.sgot->contents + h->got.offset); 6147 return TRUE; 6148 } 6149 } 6150 else if (bfd_link_pic (info) 6151 && SYMBOL_REFERENCES_LOCAL (info, h)) 6152 { 6153 if (!h->def_regular) 6154 return FALSE; 6155 BFD_ASSERT((h->got.offset & 1) != 0); 6156 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE); 6157 rela.r_addend = (h->root.u.def.value 6158 + h->root.u.def.section->output_section->vma 6159 + h->root.u.def.section->output_offset); 6160 } 6161 else 6162 { 6163 BFD_ASSERT((h->got.offset & 1) == 0); 6164do_glob_dat: 6165 bfd_put_64 (output_bfd, (bfd_vma) 0, 6166 htab->elf.sgot->contents + h->got.offset); 6167 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT); 6168 rela.r_addend = 0; 6169 } 6170 6171 elf_append_rela (output_bfd, relgot, &rela); 6172 } 6173 6174 if (h->needs_copy) 6175 { 6176 Elf_Internal_Rela rela; 6177 asection *s; 6178 6179 /* This symbol needs a copy reloc. Set it up. */ 6180 6181 if (h->dynindx == -1 6182 || (h->root.type != bfd_link_hash_defined 6183 && h->root.type != bfd_link_hash_defweak) 6184 || htab->elf.srelbss == NULL 6185 || htab->elf.sreldynrelro == NULL) 6186 abort (); 6187 6188 rela.r_offset = (h->root.u.def.value 6189 + h->root.u.def.section->output_section->vma 6190 + h->root.u.def.section->output_offset); 6191 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY); 6192 rela.r_addend = 0; 6193 if (h->root.u.def.section == htab->elf.sdynrelro) 6194 s = htab->elf.sreldynrelro; 6195 else 6196 s = htab->elf.srelbss; 6197 elf_append_rela (output_bfd, s, &rela); 6198 } 6199 6200 return TRUE; 6201} 6202 6203/* Finish up local dynamic symbol handling. We set the contents of 6204 various dynamic sections here. */ 6205 6206static bfd_boolean 6207elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf) 6208{ 6209 struct elf_link_hash_entry *h 6210 = (struct elf_link_hash_entry *) *slot; 6211 struct bfd_link_info *info 6212 = (struct bfd_link_info *) inf; 6213 6214 return elf_x86_64_finish_dynamic_symbol (info->output_bfd, 6215 info, h, NULL); 6216} 6217 6218/* Finish up undefined weak symbol handling in PIE. Fill its PLT entry 6219 here since undefined weak symbol may not be dynamic and may not be 6220 called for elf_x86_64_finish_dynamic_symbol. */ 6221 6222static bfd_boolean 6223elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh, 6224 void *inf) 6225{ 6226 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh; 6227 struct bfd_link_info *info = (struct bfd_link_info *) inf; 6228 6229 if (h->root.type != bfd_link_hash_undefweak 6230 || h->dynindx != -1) 6231 return TRUE; 6232 6233 return elf_x86_64_finish_dynamic_symbol (info->output_bfd, 6234 info, h, NULL); 6235} 6236 6237/* Used to decide how to sort relocs in an optimal manner for the 6238 dynamic linker, before writing them out. */ 6239 6240static enum elf_reloc_type_class 6241elf_x86_64_reloc_type_class (const struct bfd_link_info *info, 6242 const asection *rel_sec ATTRIBUTE_UNUSED, 6243 const Elf_Internal_Rela *rela) 6244{ 6245 bfd *abfd = info->output_bfd; 6246 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6247 struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info); 6248 6249 if (htab->elf.dynsym != NULL 6250 && htab->elf.dynsym->contents != NULL) 6251 { 6252 /* Check relocation against STT_GNU_IFUNC symbol if there are 6253 dynamic symbols. */ 6254 unsigned long r_symndx = htab->r_sym (rela->r_info); 6255 if (r_symndx != STN_UNDEF) 6256 { 6257 Elf_Internal_Sym sym; 6258 if (!bed->s->swap_symbol_in (abfd, 6259 (htab->elf.dynsym->contents 6260 + r_symndx * bed->s->sizeof_sym), 6261 0, &sym)) 6262 abort (); 6263 6264 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC) 6265 return reloc_class_ifunc; 6266 } 6267 } 6268 6269 switch ((int) ELF32_R_TYPE (rela->r_info)) 6270 { 6271 case R_X86_64_IRELATIVE: 6272 return reloc_class_ifunc; 6273 case R_X86_64_RELATIVE: 6274 case R_X86_64_RELATIVE64: 6275 return reloc_class_relative; 6276 case R_X86_64_JUMP_SLOT: 6277 return reloc_class_plt; 6278 case R_X86_64_COPY: 6279 return reloc_class_copy; 6280 default: 6281 return reloc_class_normal; 6282 } 6283} 6284 6285/* Finish up the dynamic sections. */ 6286 6287static bfd_boolean 6288elf_x86_64_finish_dynamic_sections (bfd *output_bfd, 6289 struct bfd_link_info *info) 6290{ 6291 struct elf_x86_64_link_hash_table *htab; 6292 bfd *dynobj; 6293 asection *sdyn; 6294 const struct elf_x86_64_backend_data *abed; 6295 6296 htab = elf_x86_64_hash_table (info); 6297 if (htab == NULL) 6298 return FALSE; 6299 6300 /* Use MPX backend data in case of BND relocation. Use .plt_bnd 6301 section only if there is .plt section. */ 6302 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL 6303 ? &elf_x86_64_bnd_arch_bed 6304 : get_elf_x86_64_backend_data (output_bfd)); 6305 6306 dynobj = htab->elf.dynobj; 6307 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 6308 6309 if (htab->elf.dynamic_sections_created) 6310 { 6311 bfd_byte *dyncon, *dynconend; 6312 const struct elf_backend_data *bed; 6313 bfd_size_type sizeof_dyn; 6314 6315 if (sdyn == NULL || htab->elf.sgot == NULL) 6316 abort (); 6317 6318 bed = get_elf_backend_data (dynobj); 6319 sizeof_dyn = bed->s->sizeof_dyn; 6320 dyncon = sdyn->contents; 6321 dynconend = sdyn->contents + sdyn->size; 6322 for (; dyncon < dynconend; dyncon += sizeof_dyn) 6323 { 6324 Elf_Internal_Dyn dyn; 6325 asection *s; 6326 6327 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn); 6328 6329 switch (dyn.d_tag) 6330 { 6331 default: 6332 continue; 6333 6334 case DT_PLTGOT: 6335 s = htab->elf.sgotplt; 6336 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 6337 break; 6338 6339 case DT_JMPREL: 6340 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; 6341 break; 6342 6343 case DT_PLTRELSZ: 6344 s = htab->elf.srelplt->output_section; 6345 dyn.d_un.d_val = s->size; 6346 break; 6347 6348 case DT_TLSDESC_PLT: 6349 s = htab->elf.splt; 6350 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 6351 + htab->tlsdesc_plt; 6352 break; 6353 6354 case DT_TLSDESC_GOT: 6355 s = htab->elf.sgot; 6356 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 6357 + htab->tlsdesc_got; 6358 break; 6359 } 6360 6361 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon); 6362 } 6363 6364 /* Fill in the special first entry in the procedure linkage table. */ 6365 if (htab->elf.splt && htab->elf.splt->size > 0) 6366 { 6367 /* Fill in the first entry in the procedure linkage table. */ 6368 memcpy (htab->elf.splt->contents, 6369 abed->plt0_entry, abed->plt_entry_size); 6370 /* Add offset for pushq GOT+8(%rip), since the instruction 6371 uses 6 bytes subtract this value. */ 6372 bfd_put_32 (output_bfd, 6373 (htab->elf.sgotplt->output_section->vma 6374 + htab->elf.sgotplt->output_offset 6375 + 8 6376 - htab->elf.splt->output_section->vma 6377 - htab->elf.splt->output_offset 6378 - 6), 6379 htab->elf.splt->contents + abed->plt0_got1_offset); 6380 /* Add offset for the PC-relative instruction accessing GOT+16, 6381 subtracting the offset to the end of that instruction. */ 6382 bfd_put_32 (output_bfd, 6383 (htab->elf.sgotplt->output_section->vma 6384 + htab->elf.sgotplt->output_offset 6385 + 16 6386 - htab->elf.splt->output_section->vma 6387 - htab->elf.splt->output_offset 6388 - abed->plt0_got2_insn_end), 6389 htab->elf.splt->contents + abed->plt0_got2_offset); 6390 6391 elf_section_data (htab->elf.splt->output_section) 6392 ->this_hdr.sh_entsize = abed->plt_entry_size; 6393 6394 if (htab->tlsdesc_plt) 6395 { 6396 bfd_put_64 (output_bfd, (bfd_vma) 0, 6397 htab->elf.sgot->contents + htab->tlsdesc_got); 6398 6399 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt, 6400 abed->plt0_entry, abed->plt_entry_size); 6401 6402 /* Add offset for pushq GOT+8(%rip), since the 6403 instruction uses 6 bytes subtract this value. */ 6404 bfd_put_32 (output_bfd, 6405 (htab->elf.sgotplt->output_section->vma 6406 + htab->elf.sgotplt->output_offset 6407 + 8 6408 - htab->elf.splt->output_section->vma 6409 - htab->elf.splt->output_offset 6410 - htab->tlsdesc_plt 6411 - 6), 6412 htab->elf.splt->contents 6413 + htab->tlsdesc_plt + abed->plt0_got1_offset); 6414 /* Add offset for the PC-relative instruction accessing GOT+TDG, 6415 where TGD stands for htab->tlsdesc_got, subtracting the offset 6416 to the end of that instruction. */ 6417 bfd_put_32 (output_bfd, 6418 (htab->elf.sgot->output_section->vma 6419 + htab->elf.sgot->output_offset 6420 + htab->tlsdesc_got 6421 - htab->elf.splt->output_section->vma 6422 - htab->elf.splt->output_offset 6423 - htab->tlsdesc_plt 6424 - abed->plt0_got2_insn_end), 6425 htab->elf.splt->contents 6426 + htab->tlsdesc_plt + abed->plt0_got2_offset); 6427 } 6428 } 6429 } 6430 6431 if (htab->plt_bnd != NULL) 6432 elf_section_data (htab->plt_bnd->output_section) 6433 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry); 6434 6435 if (htab->elf.sgotplt) 6436 { 6437 if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) 6438 { 6439 _bfd_error_handler 6440 (_("discarded output section: `%A'"), htab->elf.sgotplt); 6441 return FALSE; 6442 } 6443 6444 /* Fill in the first three entries in the global offset table. */ 6445 if (htab->elf.sgotplt->size > 0) 6446 { 6447 /* Set the first entry in the global offset table to the address of 6448 the dynamic section. */ 6449 if (sdyn == NULL) 6450 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents); 6451 else 6452 bfd_put_64 (output_bfd, 6453 sdyn->output_section->vma + sdyn->output_offset, 6454 htab->elf.sgotplt->contents); 6455 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */ 6456 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE); 6457 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2); 6458 } 6459 6460 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 6461 GOT_ENTRY_SIZE; 6462 } 6463 6464 /* Adjust .eh_frame for .plt section. */ 6465 if (htab->plt_eh_frame != NULL 6466 && htab->plt_eh_frame->contents != NULL) 6467 { 6468 if (htab->elf.splt != NULL 6469 && htab->elf.splt->size != 0 6470 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 6471 && htab->elf.splt->output_section != NULL 6472 && htab->plt_eh_frame->output_section != NULL) 6473 { 6474 bfd_vma plt_start = htab->elf.splt->output_section->vma; 6475 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma 6476 + htab->plt_eh_frame->output_offset 6477 + PLT_FDE_START_OFFSET; 6478 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 6479 htab->plt_eh_frame->contents 6480 + PLT_FDE_START_OFFSET); 6481 } 6482 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 6483 { 6484 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 6485 htab->plt_eh_frame, 6486 htab->plt_eh_frame->contents)) 6487 return FALSE; 6488 } 6489 } 6490 6491 /* Adjust .eh_frame for .plt.got section. */ 6492 if (htab->plt_got_eh_frame != NULL 6493 && htab->plt_got_eh_frame->contents != NULL) 6494 { 6495 if (htab->plt_got != NULL 6496 && htab->plt_got->size != 0 6497 && (htab->plt_got->flags & SEC_EXCLUDE) == 0 6498 && htab->plt_got->output_section != NULL 6499 && htab->plt_got_eh_frame->output_section != NULL) 6500 { 6501 bfd_vma plt_start = htab->plt_got->output_section->vma; 6502 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma 6503 + htab->plt_got_eh_frame->output_offset 6504 + PLT_FDE_START_OFFSET; 6505 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 6506 htab->plt_got_eh_frame->contents 6507 + PLT_FDE_START_OFFSET); 6508 } 6509 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 6510 { 6511 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 6512 htab->plt_got_eh_frame, 6513 htab->plt_got_eh_frame->contents)) 6514 return FALSE; 6515 } 6516 } 6517 6518 /* Adjust .eh_frame for .plt.bnd section. */ 6519 if (htab->plt_bnd_eh_frame != NULL 6520 && htab->plt_bnd_eh_frame->contents != NULL) 6521 { 6522 if (htab->plt_bnd != NULL 6523 && htab->plt_bnd->size != 0 6524 && (htab->plt_bnd->flags & SEC_EXCLUDE) == 0 6525 && htab->plt_bnd->output_section != NULL 6526 && htab->plt_bnd_eh_frame->output_section != NULL) 6527 { 6528 bfd_vma plt_start = htab->plt_bnd->output_section->vma; 6529 bfd_vma eh_frame_start = htab->plt_bnd_eh_frame->output_section->vma 6530 + htab->plt_bnd_eh_frame->output_offset 6531 + PLT_FDE_START_OFFSET; 6532 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 6533 htab->plt_bnd_eh_frame->contents 6534 + PLT_FDE_START_OFFSET); 6535 } 6536 if (htab->plt_bnd_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 6537 { 6538 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 6539 htab->plt_bnd_eh_frame, 6540 htab->plt_bnd_eh_frame->contents)) 6541 return FALSE; 6542 } 6543 } 6544 6545 if (htab->elf.sgot && htab->elf.sgot->size > 0) 6546 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize 6547 = GOT_ENTRY_SIZE; 6548 6549 /* Fill PLT entries for undefined weak symbols in PIE. */ 6550 if (bfd_link_pie (info)) 6551 bfd_hash_traverse (&info->hash->table, 6552 elf_x86_64_pie_finish_undefweak_symbol, 6553 info); 6554 6555 return TRUE; 6556} 6557 6558/* Fill PLT/GOT entries and allocate dynamic relocations for local 6559 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table. 6560 It has to be done before elf_link_sort_relocs is called so that 6561 dynamic relocations are properly sorted. */ 6562 6563static bfd_boolean 6564elf_x86_64_output_arch_local_syms 6565 (bfd *output_bfd ATTRIBUTE_UNUSED, 6566 struct bfd_link_info *info, 6567 void *flaginfo ATTRIBUTE_UNUSED, 6568 int (*func) (void *, const char *, 6569 Elf_Internal_Sym *, 6570 asection *, 6571 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED) 6572{ 6573 struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info); 6574 if (htab == NULL) 6575 return FALSE; 6576 6577 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */ 6578 htab_traverse (htab->loc_hash_table, 6579 elf_x86_64_finish_local_dynamic_symbol, 6580 info); 6581 6582 return TRUE; 6583} 6584 6585/* Return an array of PLT entry symbol values. */ 6586 6587static bfd_vma * 6588elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt, 6589 asection *relplt) 6590{ 6591 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 6592 arelent *p; 6593 long count, i; 6594 bfd_vma *plt_sym_val; 6595 bfd_vma plt_offset; 6596 bfd_byte *plt_contents; 6597 const struct elf_x86_64_backend_data *bed; 6598 Elf_Internal_Shdr *hdr; 6599 asection *plt_bnd; 6600 6601 /* Get the .plt section contents. PLT passed down may point to the 6602 .plt.bnd section. Make sure that PLT always points to the .plt 6603 section. */ 6604 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd"); 6605 if (plt_bnd) 6606 { 6607 if (plt != plt_bnd) 6608 abort (); 6609 plt = bfd_get_section_by_name (abfd, ".plt"); 6610 if (plt == NULL) 6611 abort (); 6612 bed = &elf_x86_64_bnd_arch_bed; 6613 } 6614 else 6615 bed = get_elf_x86_64_backend_data (abfd); 6616 6617 plt_contents = (bfd_byte *) bfd_malloc (plt->size); 6618 if (plt_contents == NULL) 6619 return NULL; 6620 if (!bfd_get_section_contents (abfd, (asection *) plt, 6621 plt_contents, 0, plt->size)) 6622 { 6623bad_return: 6624 free (plt_contents); 6625 return NULL; 6626 } 6627 6628 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 6629 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE)) 6630 goto bad_return; 6631 6632 hdr = &elf_section_data (relplt)->this_hdr; 6633 count = relplt->size / hdr->sh_entsize; 6634 6635 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count); 6636 if (plt_sym_val == NULL) 6637 goto bad_return; 6638 6639 for (i = 0; i < count; i++) 6640 plt_sym_val[i] = -1; 6641 6642 plt_offset = bed->plt_entry_size; 6643 p = relplt->relocation; 6644 for (i = 0; i < count; i++, p++) 6645 { 6646 long reloc_index; 6647 6648 /* Skip unknown relocation. */ 6649 if (p->howto == NULL) 6650 continue; 6651 6652 if (p->howto->type != R_X86_64_JUMP_SLOT 6653 && p->howto->type != R_X86_64_IRELATIVE) 6654 continue; 6655 6656 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset 6657 + bed->plt_reloc_offset)); 6658 if (reloc_index < count) 6659 { 6660 if (plt_bnd) 6661 { 6662 /* This is the index in .plt section. */ 6663 long plt_index = plt_offset / bed->plt_entry_size; 6664 /* Store VMA + the offset in .plt.bnd section. */ 6665 plt_sym_val[reloc_index] = 6666 (plt_bnd->vma 6667 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry)); 6668 } 6669 else 6670 plt_sym_val[reloc_index] = plt->vma + plt_offset; 6671 } 6672 plt_offset += bed->plt_entry_size; 6673 6674 /* PR binutils/18437: Skip extra relocations in the .rela.plt 6675 section. */ 6676 if (plt_offset >= plt->size) 6677 break; 6678 } 6679 6680 free (plt_contents); 6681 6682 return plt_sym_val; 6683} 6684 6685/* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section 6686 support. */ 6687 6688static long 6689elf_x86_64_get_synthetic_symtab (bfd *abfd, 6690 long symcount, 6691 asymbol **syms, 6692 long dynsymcount, 6693 asymbol **dynsyms, 6694 asymbol **ret) 6695{ 6696 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab 6697 as PLT if it exists. */ 6698 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd"); 6699 if (plt == NULL) 6700 plt = bfd_get_section_by_name (abfd, ".plt"); 6701 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms, 6702 dynsymcount, dynsyms, ret, 6703 plt, 6704 elf_x86_64_get_plt_sym_val); 6705} 6706 6707/* Handle an x86-64 specific section when reading an object file. This 6708 is called when elfcode.h finds a section with an unknown type. */ 6709 6710static bfd_boolean 6711elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, 6712 const char *name, int shindex) 6713{ 6714 if (hdr->sh_type != SHT_X86_64_UNWIND) 6715 return FALSE; 6716 6717 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 6718 return FALSE; 6719 6720 return TRUE; 6721} 6722 6723/* Hook called by the linker routine which adds symbols from an object 6724 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead 6725 of .bss. */ 6726 6727static bfd_boolean 6728elf_x86_64_add_symbol_hook (bfd *abfd, 6729 struct bfd_link_info *info ATTRIBUTE_UNUSED, 6730 Elf_Internal_Sym *sym, 6731 const char **namep ATTRIBUTE_UNUSED, 6732 flagword *flagsp ATTRIBUTE_UNUSED, 6733 asection **secp, 6734 bfd_vma *valp) 6735{ 6736 asection *lcomm; 6737 6738 switch (sym->st_shndx) 6739 { 6740 case SHN_X86_64_LCOMMON: 6741 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON"); 6742 if (lcomm == NULL) 6743 { 6744 lcomm = bfd_make_section_with_flags (abfd, 6745 "LARGE_COMMON", 6746 (SEC_ALLOC 6747 | SEC_IS_COMMON 6748 | SEC_LINKER_CREATED)); 6749 if (lcomm == NULL) 6750 return FALSE; 6751 elf_section_flags (lcomm) |= SHF_X86_64_LARGE; 6752 } 6753 *secp = lcomm; 6754 *valp = sym->st_size; 6755 return TRUE; 6756 } 6757 6758 return TRUE; 6759} 6760 6761 6762/* Given a BFD section, try to locate the corresponding ELF section 6763 index. */ 6764 6765static bfd_boolean 6766elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 6767 asection *sec, int *index_return) 6768{ 6769 if (sec == &_bfd_elf_large_com_section) 6770 { 6771 *index_return = SHN_X86_64_LCOMMON; 6772 return TRUE; 6773 } 6774 return FALSE; 6775} 6776 6777/* Process a symbol. */ 6778 6779static void 6780elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, 6781 asymbol *asym) 6782{ 6783 elf_symbol_type *elfsym = (elf_symbol_type *) asym; 6784 6785 switch (elfsym->internal_elf_sym.st_shndx) 6786 { 6787 case SHN_X86_64_LCOMMON: 6788 asym->section = &_bfd_elf_large_com_section; 6789 asym->value = elfsym->internal_elf_sym.st_size; 6790 /* Common symbol doesn't set BSF_GLOBAL. */ 6791 asym->flags &= ~BSF_GLOBAL; 6792 break; 6793 } 6794} 6795 6796static bfd_boolean 6797elf_x86_64_common_definition (Elf_Internal_Sym *sym) 6798{ 6799 return (sym->st_shndx == SHN_COMMON 6800 || sym->st_shndx == SHN_X86_64_LCOMMON); 6801} 6802 6803static unsigned int 6804elf_x86_64_common_section_index (asection *sec) 6805{ 6806 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0) 6807 return SHN_COMMON; 6808 else 6809 return SHN_X86_64_LCOMMON; 6810} 6811 6812static asection * 6813elf_x86_64_common_section (asection *sec) 6814{ 6815 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0) 6816 return bfd_com_section_ptr; 6817 else 6818 return &_bfd_elf_large_com_section; 6819} 6820 6821static bfd_boolean 6822elf_x86_64_merge_symbol (struct elf_link_hash_entry *h, 6823 const Elf_Internal_Sym *sym, 6824 asection **psec, 6825 bfd_boolean newdef, 6826 bfd_boolean olddef, 6827 bfd *oldbfd, 6828 const asection *oldsec) 6829{ 6830 /* A normal common symbol and a large common symbol result in a 6831 normal common symbol. We turn the large common symbol into a 6832 normal one. */ 6833 if (!olddef 6834 && h->root.type == bfd_link_hash_common 6835 && !newdef 6836 && bfd_is_com_section (*psec) 6837 && oldsec != *psec) 6838 { 6839 if (sym->st_shndx == SHN_COMMON 6840 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0) 6841 { 6842 h->root.u.c.p->section 6843 = bfd_make_section_old_way (oldbfd, "COMMON"); 6844 h->root.u.c.p->section->flags = SEC_ALLOC; 6845 } 6846 else if (sym->st_shndx == SHN_X86_64_LCOMMON 6847 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0) 6848 *psec = bfd_com_section_ptr; 6849 } 6850 6851 return TRUE; 6852} 6853 6854static int 6855elf_x86_64_additional_program_headers (bfd *abfd, 6856 struct bfd_link_info *info ATTRIBUTE_UNUSED) 6857{ 6858 asection *s; 6859 int count = 0; 6860 6861 /* Check to see if we need a large readonly segment. */ 6862 s = bfd_get_section_by_name (abfd, ".lrodata"); 6863 if (s && (s->flags & SEC_LOAD)) 6864 count++; 6865 6866 /* Check to see if we need a large data segment. Since .lbss sections 6867 is placed right after the .bss section, there should be no need for 6868 a large data segment just because of .lbss. */ 6869 s = bfd_get_section_by_name (abfd, ".ldata"); 6870 if (s && (s->flags & SEC_LOAD)) 6871 count++; 6872 6873 return count; 6874} 6875 6876/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 6877 6878static bfd_boolean 6879elf_x86_64_hash_symbol (struct elf_link_hash_entry *h) 6880{ 6881 if (h->plt.offset != (bfd_vma) -1 6882 && !h->def_regular 6883 && !h->pointer_equality_needed) 6884 return FALSE; 6885 6886 return _bfd_elf_hash_symbol (h); 6887} 6888 6889/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */ 6890 6891static bfd_boolean 6892elf_x86_64_relocs_compatible (const bfd_target *input, 6893 const bfd_target *output) 6894{ 6895 return ((xvec_get_elf_backend_data (input)->s->elfclass 6896 == xvec_get_elf_backend_data (output)->s->elfclass) 6897 && _bfd_elf_relocs_compatible (input, output)); 6898} 6899 6900static const struct bfd_elf_special_section 6901 elf_x86_64_special_sections[]= 6902{ 6903 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, 6904 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE}, 6905 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE}, 6906 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, 6907 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE}, 6908 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE}, 6909 { NULL, 0, 0, 0, 0 } 6910}; 6911 6912#define TARGET_LITTLE_SYM x86_64_elf64_vec 6913#define TARGET_LITTLE_NAME "elf64-x86-64" 6914#define ELF_ARCH bfd_arch_i386 6915#define ELF_TARGET_ID X86_64_ELF_DATA 6916#define ELF_MACHINE_CODE EM_X86_64 6917#define ELF_MAXPAGESIZE 0x200000 6918#define ELF_MINPAGESIZE 0x1000 6919#define ELF_COMMONPAGESIZE 0x1000 6920 6921#define elf_backend_can_gc_sections 1 6922#define elf_backend_can_refcount 1 6923#define elf_backend_want_got_plt 1 6924#define elf_backend_plt_readonly 1 6925#define elf_backend_want_plt_sym 0 6926#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3) 6927#define elf_backend_rela_normal 1 6928#define elf_backend_plt_alignment 4 6929#define elf_backend_extern_protected_data 1 6930#define elf_backend_caches_rawsize 1 6931#define elf_backend_dtrel_excludes_plt 1 6932#define elf_backend_want_dynrelro 1 6933 6934#define elf_info_to_howto elf_x86_64_info_to_howto 6935 6936#define bfd_elf64_bfd_link_hash_table_create \ 6937 elf_x86_64_link_hash_table_create 6938#define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup 6939#define bfd_elf64_bfd_reloc_name_lookup \ 6940 elf_x86_64_reloc_name_lookup 6941 6942#define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol 6943#define elf_backend_relocs_compatible elf_x86_64_relocs_compatible 6944#define elf_backend_check_relocs elf_x86_64_check_relocs 6945#define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol 6946#define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections 6947#define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections 6948#define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol 6949#define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms 6950#define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook 6951#define elf_backend_grok_prstatus elf_x86_64_grok_prstatus 6952#define elf_backend_grok_psinfo elf_x86_64_grok_psinfo 6953#ifdef CORE_HEADER 6954#define elf_backend_write_core_note elf_x86_64_write_core_note 6955#endif 6956#define elf_backend_reloc_type_class elf_x86_64_reloc_type_class 6957#define elf_backend_relocate_section elf_x86_64_relocate_section 6958#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections 6959#define elf_backend_always_size_sections elf_x86_64_always_size_sections 6960#define elf_backend_init_index_section _bfd_elf_init_1_index_section 6961#define elf_backend_object_p elf64_x86_64_elf_object_p 6962#define bfd_elf64_mkobject elf_x86_64_mkobject 6963#define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab 6964 6965#define elf_backend_section_from_shdr \ 6966 elf_x86_64_section_from_shdr 6967 6968#define elf_backend_section_from_bfd_section \ 6969 elf_x86_64_elf_section_from_bfd_section 6970#define elf_backend_add_symbol_hook \ 6971 elf_x86_64_add_symbol_hook 6972#define elf_backend_symbol_processing \ 6973 elf_x86_64_symbol_processing 6974#define elf_backend_common_section_index \ 6975 elf_x86_64_common_section_index 6976#define elf_backend_common_section \ 6977 elf_x86_64_common_section 6978#define elf_backend_common_definition \ 6979 elf_x86_64_common_definition 6980#define elf_backend_merge_symbol \ 6981 elf_x86_64_merge_symbol 6982#define elf_backend_special_sections \ 6983 elf_x86_64_special_sections 6984#define elf_backend_additional_program_headers \ 6985 elf_x86_64_additional_program_headers 6986#define elf_backend_hash_symbol \ 6987 elf_x86_64_hash_symbol 6988#define elf_backend_omit_section_dynsym \ 6989 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 6990#define elf_backend_fixup_symbol \ 6991 elf_x86_64_fixup_symbol 6992 6993#include "elf64-target.h" 6994 6995/* CloudABI support. */ 6996 6997#undef TARGET_LITTLE_SYM 6998#define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec 6999#undef TARGET_LITTLE_NAME 7000#define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi" 7001 7002#undef ELF_OSABI 7003#define ELF_OSABI ELFOSABI_CLOUDABI 7004 7005#undef elf64_bed 7006#define elf64_bed elf64_x86_64_cloudabi_bed 7007 7008#include "elf64-target.h" 7009 7010/* FreeBSD support. */ 7011 7012#undef TARGET_LITTLE_SYM 7013#define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec 7014#undef TARGET_LITTLE_NAME 7015#define TARGET_LITTLE_NAME "elf64-x86-64-freebsd" 7016 7017#undef ELF_OSABI 7018#define ELF_OSABI ELFOSABI_FREEBSD 7019 7020#undef elf64_bed 7021#define elf64_bed elf64_x86_64_fbsd_bed 7022 7023#include "elf64-target.h" 7024 7025/* Solaris 2 support. */ 7026 7027#undef TARGET_LITTLE_SYM 7028#define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec 7029#undef TARGET_LITTLE_NAME 7030#define TARGET_LITTLE_NAME "elf64-x86-64-sol2" 7031 7032/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE 7033 objects won't be recognized. */ 7034#undef ELF_OSABI 7035 7036#undef elf64_bed 7037#define elf64_bed elf64_x86_64_sol2_bed 7038 7039/* The 64-bit static TLS arena size is rounded to the nearest 16-byte 7040 boundary. */ 7041#undef elf_backend_static_tls_alignment 7042#define elf_backend_static_tls_alignment 16 7043 7044/* The Solaris 2 ABI requires a plt symbol on all platforms. 7045 7046 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output 7047 File, p.63. */ 7048#undef elf_backend_want_plt_sym 7049#define elf_backend_want_plt_sym 1 7050 7051#undef elf_backend_strtab_flags 7052#define elf_backend_strtab_flags SHF_STRINGS 7053 7054static bfd_boolean 7055elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED, 7056 bfd *obfd ATTRIBUTE_UNUSED, 7057 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED, 7058 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED) 7059{ 7060 /* PR 19938: FIXME: Need to add code for setting the sh_info 7061 and sh_link fields of Solaris specific section types. */ 7062 return FALSE; 7063} 7064 7065#undef elf_backend_copy_special_section_fields 7066#define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields 7067 7068#include "elf64-target.h" 7069 7070/* Native Client support. */ 7071 7072static bfd_boolean 7073elf64_x86_64_nacl_elf_object_p (bfd *abfd) 7074{ 7075 /* Set the right machine number for a NaCl x86-64 ELF64 file. */ 7076 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl); 7077 return TRUE; 7078} 7079 7080#undef TARGET_LITTLE_SYM 7081#define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec 7082#undef TARGET_LITTLE_NAME 7083#define TARGET_LITTLE_NAME "elf64-x86-64-nacl" 7084#undef elf64_bed 7085#define elf64_bed elf64_x86_64_nacl_bed 7086 7087#undef ELF_MAXPAGESIZE 7088#undef ELF_MINPAGESIZE 7089#undef ELF_COMMONPAGESIZE 7090#define ELF_MAXPAGESIZE 0x10000 7091#define ELF_MINPAGESIZE 0x10000 7092#define ELF_COMMONPAGESIZE 0x10000 7093 7094/* Restore defaults. */ 7095#undef ELF_OSABI 7096#undef elf_backend_static_tls_alignment 7097#undef elf_backend_want_plt_sym 7098#define elf_backend_want_plt_sym 0 7099#undef elf_backend_strtab_flags 7100#undef elf_backend_copy_special_section_fields 7101 7102/* NaCl uses substantially different PLT entries for the same effects. */ 7103 7104#undef elf_backend_plt_alignment 7105#define elf_backend_plt_alignment 5 7106#define NACL_PLT_ENTRY_SIZE 64 7107#define NACLMASK 0xe0 /* 32-byte alignment mask. */ 7108 7109static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] = 7110 { 7111 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 7112 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */ 7113 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ 7114 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ 7115 0x41, 0xff, 0xe3, /* jmpq *%r11 */ 7116 7117 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */ 7118 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */ 7119 7120 /* 32 bytes of nop to pad out to the standard size. */ 7121 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 7122 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ 7123 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 7124 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ 7125 0x66, /* excess data16 prefix */ 7126 0x90 /* nop */ 7127 }; 7128 7129static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] = 7130 { 7131 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */ 7132 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */ 7133 0x4d, 0x01, 0xfb, /* add %r15, %r11 */ 7134 0x41, 0xff, 0xe3, /* jmpq *%r11 */ 7135 7136 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */ 7137 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 7138 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ 7139 7140 /* Lazy GOT entries point here (32-byte aligned). */ 7141 0x68, /* pushq immediate */ 7142 0, 0, 0, 0, /* replaced with index into relocation table. */ 7143 0xe9, /* jmp relative */ 7144 0, 0, 0, 0, /* replaced with offset to start of .plt0. */ 7145 7146 /* 22 bytes of nop to pad out to the standard size. */ 7147 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */ 7148 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */ 7149 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */ 7150 }; 7151 7152/* .eh_frame covering the .plt section. */ 7153 7154static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] = 7155 { 7156#if (PLT_CIE_LENGTH != 20 \ 7157 || PLT_FDE_LENGTH != 36 \ 7158 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \ 7159 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12) 7160# error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!" 7161#endif 7162 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 7163 0, 0, 0, 0, /* CIE ID */ 7164 1, /* CIE version */ 7165 'z', 'R', 0, /* Augmentation string */ 7166 1, /* Code alignment factor */ 7167 0x78, /* Data alignment factor */ 7168 16, /* Return address column */ 7169 1, /* Augmentation size */ 7170 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */ 7171 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */ 7172 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */ 7173 DW_CFA_nop, DW_CFA_nop, 7174 7175 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */ 7176 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */ 7177 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */ 7178 0, 0, 0, 0, /* .plt size goes here */ 7179 0, /* Augmentation size */ 7180 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */ 7181 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */ 7182 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */ 7183 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */ 7184 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */ 7185 13, /* Block length */ 7186 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */ 7187 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */ 7188 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge, 7189 DW_OP_lit3, DW_OP_shl, DW_OP_plus, 7190 DW_CFA_nop, DW_CFA_nop 7191 }; 7192 7193static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed = 7194 { 7195 elf_x86_64_nacl_plt0_entry, /* plt0_entry */ 7196 elf_x86_64_nacl_plt_entry, /* plt_entry */ 7197 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */ 7198 2, /* plt0_got1_offset */ 7199 9, /* plt0_got2_offset */ 7200 13, /* plt0_got2_insn_end */ 7201 3, /* plt_got_offset */ 7202 33, /* plt_reloc_offset */ 7203 38, /* plt_plt_offset */ 7204 7, /* plt_got_insn_size */ 7205 42, /* plt_plt_insn_end */ 7206 32, /* plt_lazy_offset */ 7207 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */ 7208 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */ 7209 NULL, /* eh_frame_plt_got */ 7210 0, /* eh_frame_plt_got_size */ 7211 }; 7212 7213#undef elf_backend_arch_data 7214#define elf_backend_arch_data &elf_x86_64_nacl_arch_bed 7215 7216#undef elf_backend_object_p 7217#define elf_backend_object_p elf64_x86_64_nacl_elf_object_p 7218#undef elf_backend_modify_segment_map 7219#define elf_backend_modify_segment_map nacl_modify_segment_map 7220#undef elf_backend_modify_program_headers 7221#define elf_backend_modify_program_headers nacl_modify_program_headers 7222#undef elf_backend_final_write_processing 7223#define elf_backend_final_write_processing nacl_final_write_processing 7224 7225#include "elf64-target.h" 7226 7227/* Native Client x32 support. */ 7228 7229static bfd_boolean 7230elf32_x86_64_nacl_elf_object_p (bfd *abfd) 7231{ 7232 /* Set the right machine number for a NaCl x86-64 ELF32 file. */ 7233 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl); 7234 return TRUE; 7235} 7236 7237#undef TARGET_LITTLE_SYM 7238#define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec 7239#undef TARGET_LITTLE_NAME 7240#define TARGET_LITTLE_NAME "elf32-x86-64-nacl" 7241#undef elf32_bed 7242#define elf32_bed elf32_x86_64_nacl_bed 7243 7244#define bfd_elf32_bfd_link_hash_table_create \ 7245 elf_x86_64_link_hash_table_create 7246#define bfd_elf32_bfd_reloc_type_lookup \ 7247 elf_x86_64_reloc_type_lookup 7248#define bfd_elf32_bfd_reloc_name_lookup \ 7249 elf_x86_64_reloc_name_lookup 7250#define bfd_elf32_mkobject \ 7251 elf_x86_64_mkobject 7252#define bfd_elf32_get_synthetic_symtab \ 7253 elf_x86_64_get_synthetic_symtab 7254 7255#undef elf_backend_object_p 7256#define elf_backend_object_p \ 7257 elf32_x86_64_nacl_elf_object_p 7258 7259#undef elf_backend_bfd_from_remote_memory 7260#define elf_backend_bfd_from_remote_memory \ 7261 _bfd_elf32_bfd_from_remote_memory 7262 7263#undef elf_backend_size_info 7264#define elf_backend_size_info \ 7265 _bfd_elf32_size_info 7266 7267#include "elf32-target.h" 7268 7269/* Restore defaults. */ 7270#undef elf_backend_object_p 7271#define elf_backend_object_p elf64_x86_64_elf_object_p 7272#undef elf_backend_bfd_from_remote_memory 7273#undef elf_backend_size_info 7274#undef elf_backend_modify_segment_map 7275#undef elf_backend_modify_program_headers 7276#undef elf_backend_final_write_processing 7277 7278/* Intel L1OM support. */ 7279 7280static bfd_boolean 7281elf64_l1om_elf_object_p (bfd *abfd) 7282{ 7283 /* Set the right machine number for an L1OM elf64 file. */ 7284 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om); 7285 return TRUE; 7286} 7287 7288#undef TARGET_LITTLE_SYM 7289#define TARGET_LITTLE_SYM l1om_elf64_vec 7290#undef TARGET_LITTLE_NAME 7291#define TARGET_LITTLE_NAME "elf64-l1om" 7292#undef ELF_ARCH 7293#define ELF_ARCH bfd_arch_l1om 7294 7295#undef ELF_MACHINE_CODE 7296#define ELF_MACHINE_CODE EM_L1OM 7297 7298#undef ELF_OSABI 7299 7300#undef elf64_bed 7301#define elf64_bed elf64_l1om_bed 7302 7303#undef elf_backend_object_p 7304#define elf_backend_object_p elf64_l1om_elf_object_p 7305 7306/* Restore defaults. */ 7307#undef ELF_MAXPAGESIZE 7308#undef ELF_MINPAGESIZE 7309#undef ELF_COMMONPAGESIZE 7310#define ELF_MAXPAGESIZE 0x200000 7311#define ELF_MINPAGESIZE 0x1000 7312#define ELF_COMMONPAGESIZE 0x1000 7313#undef elf_backend_plt_alignment 7314#define elf_backend_plt_alignment 4 7315#undef elf_backend_arch_data 7316#define elf_backend_arch_data &elf_x86_64_arch_bed 7317 7318#include "elf64-target.h" 7319 7320/* FreeBSD L1OM support. */ 7321 7322#undef TARGET_LITTLE_SYM 7323#define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec 7324#undef TARGET_LITTLE_NAME 7325#define TARGET_LITTLE_NAME "elf64-l1om-freebsd" 7326 7327#undef ELF_OSABI 7328#define ELF_OSABI ELFOSABI_FREEBSD 7329 7330#undef elf64_bed 7331#define elf64_bed elf64_l1om_fbsd_bed 7332 7333#include "elf64-target.h" 7334 7335/* Intel K1OM support. */ 7336 7337static bfd_boolean 7338elf64_k1om_elf_object_p (bfd *abfd) 7339{ 7340 /* Set the right machine number for an K1OM elf64 file. */ 7341 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om); 7342 return TRUE; 7343} 7344 7345#undef TARGET_LITTLE_SYM 7346#define TARGET_LITTLE_SYM k1om_elf64_vec 7347#undef TARGET_LITTLE_NAME 7348#define TARGET_LITTLE_NAME "elf64-k1om" 7349#undef ELF_ARCH 7350#define ELF_ARCH bfd_arch_k1om 7351 7352#undef ELF_MACHINE_CODE 7353#define ELF_MACHINE_CODE EM_K1OM 7354 7355#undef ELF_OSABI 7356 7357#undef elf64_bed 7358#define elf64_bed elf64_k1om_bed 7359 7360#undef elf_backend_object_p 7361#define elf_backend_object_p elf64_k1om_elf_object_p 7362 7363#undef elf_backend_static_tls_alignment 7364 7365#undef elf_backend_want_plt_sym 7366#define elf_backend_want_plt_sym 0 7367 7368#include "elf64-target.h" 7369 7370/* FreeBSD K1OM support. */ 7371 7372#undef TARGET_LITTLE_SYM 7373#define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec 7374#undef TARGET_LITTLE_NAME 7375#define TARGET_LITTLE_NAME "elf64-k1om-freebsd" 7376 7377#undef ELF_OSABI 7378#define ELF_OSABI ELFOSABI_FREEBSD 7379 7380#undef elf64_bed 7381#define elf64_bed elf64_k1om_fbsd_bed 7382 7383#include "elf64-target.h" 7384 7385/* 32bit x86-64 support. */ 7386 7387#undef TARGET_LITTLE_SYM 7388#define TARGET_LITTLE_SYM x86_64_elf32_vec 7389#undef TARGET_LITTLE_NAME 7390#define TARGET_LITTLE_NAME "elf32-x86-64" 7391#undef elf32_bed 7392 7393#undef ELF_ARCH 7394#define ELF_ARCH bfd_arch_i386 7395 7396#undef ELF_MACHINE_CODE 7397#define ELF_MACHINE_CODE EM_X86_64 7398 7399#undef ELF_OSABI 7400 7401#undef elf_backend_object_p 7402#define elf_backend_object_p \ 7403 elf32_x86_64_elf_object_p 7404 7405#undef elf_backend_bfd_from_remote_memory 7406#define elf_backend_bfd_from_remote_memory \ 7407 _bfd_elf32_bfd_from_remote_memory 7408 7409#undef elf_backend_size_info 7410#define elf_backend_size_info \ 7411 _bfd_elf32_size_info 7412 7413#include "elf32-target.h" 7414