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