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