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