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