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