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