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