1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "elf-vxworks.h"
29 #include "bfd_stdint.h"
34 /* 386 uses REL relocations instead of RELA. */
39 static reloc_howto_type elf_howto_table
[]=
41 HOWTO(R_386_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_bitfield
,
42 bfd_elf_generic_reloc
, "R_386_NONE",
43 TRUE
, 0x00000000, 0x00000000, FALSE
),
44 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
45 bfd_elf_generic_reloc
, "R_386_32",
46 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
47 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
48 bfd_elf_generic_reloc
, "R_386_PC32",
49 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
50 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
51 bfd_elf_generic_reloc
, "R_386_GOT32",
52 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
53 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_386_PLT32",
55 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
56 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
57 bfd_elf_generic_reloc
, "R_386_COPY",
58 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
59 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
60 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
61 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
62 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
64 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
65 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_386_RELATIVE",
67 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
68 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
, "R_386_GOTOFF",
70 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
71 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
72 bfd_elf_generic_reloc
, "R_386_GOTPC",
73 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
85 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
86 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_386_TLS_IE",
88 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
89 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
91 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
92 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_386_TLS_LE",
94 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
95 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_386_TLS_GD",
97 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
98 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
100 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
101 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_386_16",
103 TRUE
, 0xffff, 0xffff, FALSE
),
104 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_386_PC16",
106 TRUE
, 0xffff, 0xffff, TRUE
),
107 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_386_8",
109 TRUE
, 0xff, 0xff, FALSE
),
110 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_386_PC8",
112 TRUE
, 0xff, 0xff, TRUE
),
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
118 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
119 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
120 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
122 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
123 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
125 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
126 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
128 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
129 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
131 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
132 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
133 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
134 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
136 HOWTO(R_386_TLS_GOTDESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
137 bfd_elf_generic_reloc
, "R_386_TLS_GOTDESC",
138 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
139 HOWTO(R_386_TLS_DESC_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
140 bfd_elf_generic_reloc
, "R_386_TLS_DESC_CALL",
142 HOWTO(R_386_TLS_DESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
143 bfd_elf_generic_reloc
, "R_386_TLS_DESC",
144 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
145 HOWTO(R_386_IRELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
146 bfd_elf_generic_reloc
, "R_386_IRELATIVE",
147 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
150 #define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
151 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
153 /* GNU extension to record C++ vtable hierarchy. */
154 HOWTO (R_386_GNU_VTINHERIT
, /* type */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
158 FALSE
, /* pc_relative */
160 complain_overflow_dont
, /* complain_on_overflow */
161 NULL
, /* special_function */
162 "R_386_GNU_VTINHERIT", /* name */
163 FALSE
, /* partial_inplace */
166 FALSE
), /* pcrel_offset */
168 /* GNU extension to record C++ vtable member usage. */
169 HOWTO (R_386_GNU_VTENTRY
, /* type */
171 2, /* size (0 = byte, 1 = short, 2 = long) */
173 FALSE
, /* pc_relative */
175 complain_overflow_dont
, /* complain_on_overflow */
176 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
177 "R_386_GNU_VTENTRY", /* name */
178 FALSE
, /* partial_inplace */
181 FALSE
) /* pcrel_offset */
183 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
187 #ifdef DEBUG_GEN_RELOC
189 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
194 static reloc_howto_type
*
195 elf_i386_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
196 bfd_reloc_code_real_type code
)
201 TRACE ("BFD_RELOC_NONE");
202 return &elf_howto_table
[R_386_NONE
];
205 TRACE ("BFD_RELOC_32");
206 return &elf_howto_table
[R_386_32
];
209 TRACE ("BFD_RELOC_CTOR");
210 return &elf_howto_table
[R_386_32
];
212 case BFD_RELOC_32_PCREL
:
213 TRACE ("BFD_RELOC_PC32");
214 return &elf_howto_table
[R_386_PC32
];
216 case BFD_RELOC_386_GOT32
:
217 TRACE ("BFD_RELOC_386_GOT32");
218 return &elf_howto_table
[R_386_GOT32
];
220 case BFD_RELOC_386_PLT32
:
221 TRACE ("BFD_RELOC_386_PLT32");
222 return &elf_howto_table
[R_386_PLT32
];
224 case BFD_RELOC_386_COPY
:
225 TRACE ("BFD_RELOC_386_COPY");
226 return &elf_howto_table
[R_386_COPY
];
228 case BFD_RELOC_386_GLOB_DAT
:
229 TRACE ("BFD_RELOC_386_GLOB_DAT");
230 return &elf_howto_table
[R_386_GLOB_DAT
];
232 case BFD_RELOC_386_JUMP_SLOT
:
233 TRACE ("BFD_RELOC_386_JUMP_SLOT");
234 return &elf_howto_table
[R_386_JUMP_SLOT
];
236 case BFD_RELOC_386_RELATIVE
:
237 TRACE ("BFD_RELOC_386_RELATIVE");
238 return &elf_howto_table
[R_386_RELATIVE
];
240 case BFD_RELOC_386_GOTOFF
:
241 TRACE ("BFD_RELOC_386_GOTOFF");
242 return &elf_howto_table
[R_386_GOTOFF
];
244 case BFD_RELOC_386_GOTPC
:
245 TRACE ("BFD_RELOC_386_GOTPC");
246 return &elf_howto_table
[R_386_GOTPC
];
248 /* These relocs are a GNU extension. */
249 case BFD_RELOC_386_TLS_TPOFF
:
250 TRACE ("BFD_RELOC_386_TLS_TPOFF");
251 return &elf_howto_table
[R_386_TLS_TPOFF
- R_386_ext_offset
];
253 case BFD_RELOC_386_TLS_IE
:
254 TRACE ("BFD_RELOC_386_TLS_IE");
255 return &elf_howto_table
[R_386_TLS_IE
- R_386_ext_offset
];
257 case BFD_RELOC_386_TLS_GOTIE
:
258 TRACE ("BFD_RELOC_386_TLS_GOTIE");
259 return &elf_howto_table
[R_386_TLS_GOTIE
- R_386_ext_offset
];
261 case BFD_RELOC_386_TLS_LE
:
262 TRACE ("BFD_RELOC_386_TLS_LE");
263 return &elf_howto_table
[R_386_TLS_LE
- R_386_ext_offset
];
265 case BFD_RELOC_386_TLS_GD
:
266 TRACE ("BFD_RELOC_386_TLS_GD");
267 return &elf_howto_table
[R_386_TLS_GD
- R_386_ext_offset
];
269 case BFD_RELOC_386_TLS_LDM
:
270 TRACE ("BFD_RELOC_386_TLS_LDM");
271 return &elf_howto_table
[R_386_TLS_LDM
- R_386_ext_offset
];
274 TRACE ("BFD_RELOC_16");
275 return &elf_howto_table
[R_386_16
- R_386_ext_offset
];
277 case BFD_RELOC_16_PCREL
:
278 TRACE ("BFD_RELOC_16_PCREL");
279 return &elf_howto_table
[R_386_PC16
- R_386_ext_offset
];
282 TRACE ("BFD_RELOC_8");
283 return &elf_howto_table
[R_386_8
- R_386_ext_offset
];
285 case BFD_RELOC_8_PCREL
:
286 TRACE ("BFD_RELOC_8_PCREL");
287 return &elf_howto_table
[R_386_PC8
- R_386_ext_offset
];
289 /* Common with Sun TLS implementation. */
290 case BFD_RELOC_386_TLS_LDO_32
:
291 TRACE ("BFD_RELOC_386_TLS_LDO_32");
292 return &elf_howto_table
[R_386_TLS_LDO_32
- R_386_tls_offset
];
294 case BFD_RELOC_386_TLS_IE_32
:
295 TRACE ("BFD_RELOC_386_TLS_IE_32");
296 return &elf_howto_table
[R_386_TLS_IE_32
- R_386_tls_offset
];
298 case BFD_RELOC_386_TLS_LE_32
:
299 TRACE ("BFD_RELOC_386_TLS_LE_32");
300 return &elf_howto_table
[R_386_TLS_LE_32
- R_386_tls_offset
];
302 case BFD_RELOC_386_TLS_DTPMOD32
:
303 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
304 return &elf_howto_table
[R_386_TLS_DTPMOD32
- R_386_tls_offset
];
306 case BFD_RELOC_386_TLS_DTPOFF32
:
307 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
308 return &elf_howto_table
[R_386_TLS_DTPOFF32
- R_386_tls_offset
];
310 case BFD_RELOC_386_TLS_TPOFF32
:
311 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
312 return &elf_howto_table
[R_386_TLS_TPOFF32
- R_386_tls_offset
];
314 case BFD_RELOC_386_TLS_GOTDESC
:
315 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
316 return &elf_howto_table
[R_386_TLS_GOTDESC
- R_386_tls_offset
];
318 case BFD_RELOC_386_TLS_DESC_CALL
:
319 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
320 return &elf_howto_table
[R_386_TLS_DESC_CALL
- R_386_tls_offset
];
322 case BFD_RELOC_386_TLS_DESC
:
323 TRACE ("BFD_RELOC_386_TLS_DESC");
324 return &elf_howto_table
[R_386_TLS_DESC
- R_386_tls_offset
];
326 case BFD_RELOC_386_IRELATIVE
:
327 TRACE ("BFD_RELOC_386_IRELATIVE");
328 return &elf_howto_table
[R_386_IRELATIVE
- R_386_tls_offset
];
330 case BFD_RELOC_VTABLE_INHERIT
:
331 TRACE ("BFD_RELOC_VTABLE_INHERIT");
332 return &elf_howto_table
[R_386_GNU_VTINHERIT
- R_386_vt_offset
];
334 case BFD_RELOC_VTABLE_ENTRY
:
335 TRACE ("BFD_RELOC_VTABLE_ENTRY");
336 return &elf_howto_table
[R_386_GNU_VTENTRY
- R_386_vt_offset
];
346 static reloc_howto_type
*
347 elf_i386_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
352 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
353 if (elf_howto_table
[i
].name
!= NULL
354 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
355 return &elf_howto_table
[i
];
360 static reloc_howto_type
*
361 elf_i386_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
365 if ((indx
= r_type
) >= R_386_standard
366 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
367 >= R_386_ext
- R_386_standard
)
368 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
369 >= R_386_irelative
- R_386_ext
)
370 && ((indx
= r_type
- R_386_vt_offset
) - R_386_irelative
371 >= R_386_vt
- R_386_irelative
))
373 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
377 BFD_ASSERT (elf_howto_table
[indx
].type
== r_type
);
378 return &elf_howto_table
[indx
];
382 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
384 Elf_Internal_Rela
*dst
)
386 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
387 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
390 /* Return whether a symbol name implies a local label. The UnixWare
391 2.1 cc generates temporary symbols that start with .X, so we
392 recognize them here. FIXME: do other SVR4 compilers also use .X?.
393 If so, we should move the .X recognition into
394 _bfd_elf_is_local_label_name. */
397 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
399 if (name
[0] == '.' && name
[1] == 'X')
402 return _bfd_elf_is_local_label_name (abfd
, name
);
405 /* Support for core dump NOTE sections. */
408 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
413 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
415 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
421 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
424 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
428 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
432 switch (note
->descsz
)
437 case 144: /* Linux/i386 */
439 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
442 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
452 /* Make a ".reg/999" section. */
453 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
454 size
, note
->descpos
+ offset
);
458 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
460 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
462 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
467 elf_tdata (abfd
)->core_program
468 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
469 elf_tdata (abfd
)->core_command
470 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
474 switch (note
->descsz
)
479 case 124: /* Linux/i386 elf_prpsinfo. */
480 elf_tdata (abfd
)->core_pid
481 = bfd_get_32 (abfd
, note
->descdata
+ 12);
482 elf_tdata (abfd
)->core_program
483 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
484 elf_tdata (abfd
)->core_command
485 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
489 /* Note that for some reason, a spurious space is tacked
490 onto the end of the args in some (at least one anyway)
491 implementations, so strip it off if it exists. */
493 char *command
= elf_tdata (abfd
)->core_command
;
494 int n
= strlen (command
);
496 if (0 < n
&& command
[n
- 1] == ' ')
497 command
[n
- 1] = '\0';
503 /* Functions for the i386 ELF linker.
505 In order to gain some understanding of code in this file without
506 knowing all the intricate details of the linker, note the
509 Functions named elf_i386_* are called by external routines, other
510 functions are only called locally. elf_i386_* functions appear
511 in this file more or less in the order in which they are called
512 from external routines. eg. elf_i386_check_relocs is called
513 early in the link process, elf_i386_finish_dynamic_sections is
514 one of the last functions. */
517 /* The name of the dynamic interpreter. This is put in the .interp
520 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
522 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
523 copying dynamic variables from a shared lib into an app's dynbss
524 section, and instead use a dynamic relocation to point into the
526 #define ELIMINATE_COPY_RELOCS 1
528 /* The size in bytes of an entry in the procedure linkage table. */
530 #define PLT_ENTRY_SIZE 16
532 /* The first entry in an absolute procedure linkage table looks like
533 this. See the SVR4 ABI i386 supplement to see how this works.
534 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
536 static const bfd_byte elf_i386_plt0_entry
[12] =
538 0xff, 0x35, /* pushl contents of address */
539 0, 0, 0, 0, /* replaced with address of .got + 4. */
540 0xff, 0x25, /* jmp indirect */
541 0, 0, 0, 0 /* replaced with address of .got + 8. */
544 /* Subsequent entries in an absolute procedure linkage table look like
547 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
549 0xff, 0x25, /* jmp indirect */
550 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
551 0x68, /* pushl immediate */
552 0, 0, 0, 0, /* replaced with offset into relocation table. */
553 0xe9, /* jmp relative */
554 0, 0, 0, 0 /* replaced with offset to start of .plt. */
557 /* The first entry in a PIC procedure linkage table look like this.
558 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
560 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
562 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
563 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
566 /* Subsequent entries in a PIC procedure linkage table look like this. */
568 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
570 0xff, 0xa3, /* jmp *offset(%ebx) */
571 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
572 0x68, /* pushl immediate */
573 0, 0, 0, 0, /* replaced with offset into relocation table. */
574 0xe9, /* jmp relative */
575 0, 0, 0, 0 /* replaced with offset to start of .plt. */
578 /* .eh_frame covering the .plt section. */
580 static const bfd_byte elf_i386_eh_frame_plt
[] =
582 #define PLT_CIE_LENGTH 20
583 #define PLT_FDE_LENGTH 36
584 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
585 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
586 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
587 0, 0, 0, 0, /* CIE ID */
589 'z', 'R', 0, /* Augmentation string */
590 1, /* Code alignment factor */
591 0x7c, /* Data alignment factor */
592 8, /* Return address column */
593 1, /* Augmentation size */
594 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
595 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
596 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
597 DW_CFA_nop
, DW_CFA_nop
,
599 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
600 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
601 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
602 0, 0, 0, 0, /* .plt size goes here */
603 0, /* Augmentation size */
604 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
605 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
606 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
607 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
608 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
609 11, /* Block length */
610 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
611 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
612 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
613 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
614 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
617 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
618 for the PLTResolve stub and then for each PLT entry. */
619 #define PLTRESOLVE_RELOCS_SHLIB 0
620 #define PLTRESOLVE_RELOCS 2
621 #define PLT_NON_JUMP_SLOT_RELOCS 2
623 /* Architecture-specific backend data for i386. */
625 struct elf_i386_backend_data
627 /* Value used to fill the unused bytes of the first PLT entry. */
628 bfd_byte plt0_pad_byte
;
630 /* True if the target system is VxWorks. */
634 #define get_elf_i386_backend_data(abfd) \
635 ((const struct elf_i386_backend_data *) \
636 get_elf_backend_data (abfd)->arch_data)
638 /* These are the standard parameters. */
639 static const struct elf_i386_backend_data elf_i386_arch_bed
=
641 0, /* plt0_pad_byte */
645 #define elf_backend_arch_data &elf_i386_arch_bed
647 /* i386 ELF linker hash entry. */
649 struct elf_i386_link_hash_entry
651 struct elf_link_hash_entry elf
;
653 /* Track dynamic relocs copied for this symbol. */
654 struct elf_dyn_relocs
*dyn_relocs
;
656 #define GOT_UNKNOWN 0
660 #define GOT_TLS_IE_POS 5
661 #define GOT_TLS_IE_NEG 6
662 #define GOT_TLS_IE_BOTH 7
663 #define GOT_TLS_GDESC 8
664 #define GOT_TLS_GD_BOTH_P(type) \
665 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
666 #define GOT_TLS_GD_P(type) \
667 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
668 #define GOT_TLS_GDESC_P(type) \
669 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
670 #define GOT_TLS_GD_ANY_P(type) \
671 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
672 unsigned char tls_type
;
674 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
675 starting at the end of the jump table. */
679 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
681 struct elf_i386_obj_tdata
683 struct elf_obj_tdata root
;
685 /* tls_type for each local got entry. */
686 char *local_got_tls_type
;
688 /* GOTPLT entries for TLS descriptors. */
689 bfd_vma
*local_tlsdesc_gotent
;
692 #define elf_i386_tdata(abfd) \
693 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
695 #define elf_i386_local_got_tls_type(abfd) \
696 (elf_i386_tdata (abfd)->local_got_tls_type)
698 #define elf_i386_local_tlsdesc_gotent(abfd) \
699 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
701 #define is_i386_elf(bfd) \
702 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
703 && elf_tdata (bfd) != NULL \
704 && elf_object_id (bfd) == I386_ELF_DATA)
707 elf_i386_mkobject (bfd
*abfd
)
709 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
713 /* i386 ELF linker hash table. */
715 struct elf_i386_link_hash_table
717 struct elf_link_hash_table elf
;
719 /* Short-cuts to get to dynamic linker sections. */
722 asection
*plt_eh_frame
;
726 bfd_signed_vma refcount
;
730 /* The amount of space used by the reserved portion of the sgotplt
731 section, plus whatever space is used by the jump slots. */
732 bfd_vma sgotplt_jump_table_size
;
734 /* Small local sym cache. */
735 struct sym_cache sym_cache
;
737 /* _TLS_MODULE_BASE_ symbol. */
738 struct bfd_link_hash_entry
*tls_module_base
;
740 /* Used by local STT_GNU_IFUNC symbols. */
741 htab_t loc_hash_table
;
742 void * loc_hash_memory
;
744 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
747 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
748 bfd_vma next_tls_desc_index
;
751 /* Get the i386 ELF linker hash table from a link_info structure. */
753 #define elf_i386_hash_table(p) \
754 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
755 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
757 #define elf_i386_compute_jump_table_size(htab) \
758 ((htab)->next_tls_desc_index * 4)
760 /* Create an entry in an i386 ELF linker hash table. */
762 static struct bfd_hash_entry
*
763 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
764 struct bfd_hash_table
*table
,
767 /* Allocate the structure if it has not already been allocated by a
771 entry
= (struct bfd_hash_entry
*)
772 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
777 /* Call the allocation method of the superclass. */
778 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
781 struct elf_i386_link_hash_entry
*eh
;
783 eh
= (struct elf_i386_link_hash_entry
*) entry
;
784 eh
->dyn_relocs
= NULL
;
785 eh
->tls_type
= GOT_UNKNOWN
;
786 eh
->tlsdesc_got
= (bfd_vma
) -1;
792 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
793 for local symbol so that we can handle local STT_GNU_IFUNC symbols
794 as global symbol. We reuse indx and dynstr_index for local symbol
795 hash since they aren't used by global symbols in this backend. */
798 elf_i386_local_htab_hash (const void *ptr
)
800 struct elf_link_hash_entry
*h
801 = (struct elf_link_hash_entry
*) ptr
;
802 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
805 /* Compare local hash entries. */
808 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
810 struct elf_link_hash_entry
*h1
811 = (struct elf_link_hash_entry
*) ptr1
;
812 struct elf_link_hash_entry
*h2
813 = (struct elf_link_hash_entry
*) ptr2
;
815 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
818 /* Find and/or create a hash entry for local symbol. */
820 static struct elf_link_hash_entry
*
821 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
822 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
825 struct elf_i386_link_hash_entry e
, *ret
;
826 asection
*sec
= abfd
->sections
;
827 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
828 ELF32_R_SYM (rel
->r_info
));
831 e
.elf
.indx
= sec
->id
;
832 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
833 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
834 create
? INSERT
: NO_INSERT
);
841 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
845 ret
= (struct elf_i386_link_hash_entry
*)
846 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
847 sizeof (struct elf_i386_link_hash_entry
));
850 memset (ret
, 0, sizeof (*ret
));
851 ret
->elf
.indx
= sec
->id
;
852 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
853 ret
->elf
.dynindx
= -1;
859 /* Create an i386 ELF linker hash table. */
861 static struct bfd_link_hash_table
*
862 elf_i386_link_hash_table_create (bfd
*abfd
)
864 struct elf_i386_link_hash_table
*ret
;
865 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
867 ret
= (struct elf_i386_link_hash_table
*) bfd_malloc (amt
);
871 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
872 elf_i386_link_hash_newfunc
,
873 sizeof (struct elf_i386_link_hash_entry
),
882 ret
->plt_eh_frame
= NULL
;
883 ret
->tls_ldm_got
.refcount
= 0;
884 ret
->next_tls_desc_index
= 0;
885 ret
->sgotplt_jump_table_size
= 0;
886 ret
->sym_cache
.abfd
= NULL
;
887 ret
->srelplt2
= NULL
;
888 ret
->tls_module_base
= NULL
;
890 ret
->loc_hash_table
= htab_try_create (1024,
891 elf_i386_local_htab_hash
,
892 elf_i386_local_htab_eq
,
894 ret
->loc_hash_memory
= objalloc_create ();
895 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
901 return &ret
->elf
.root
;
904 /* Destroy an i386 ELF linker hash table. */
907 elf_i386_link_hash_table_free (struct bfd_link_hash_table
*hash
)
909 struct elf_i386_link_hash_table
*htab
910 = (struct elf_i386_link_hash_table
*) hash
;
912 if (htab
->loc_hash_table
)
913 htab_delete (htab
->loc_hash_table
);
914 if (htab
->loc_hash_memory
)
915 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
916 _bfd_generic_link_hash_table_free (hash
);
919 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
920 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
924 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
926 struct elf_i386_link_hash_table
*htab
;
928 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
931 htab
= elf_i386_hash_table (info
);
935 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
937 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
940 || (!info
->shared
&& !htab
->srelbss
))
943 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
944 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
948 if (!info
->no_ld_generated_unwind_info
949 && bfd_get_section_by_name (dynobj
, ".eh_frame") == NULL
950 && htab
->elf
.splt
!= NULL
)
952 flagword flags
= get_elf_backend_data (dynobj
)->dynamic_sec_flags
;
954 = bfd_make_section_with_flags (dynobj
, ".eh_frame",
955 flags
| SEC_READONLY
);
956 if (htab
->plt_eh_frame
== NULL
957 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
960 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
961 htab
->plt_eh_frame
->contents
962 = bfd_alloc (dynobj
, htab
->plt_eh_frame
->size
);
963 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
964 sizeof (elf_i386_eh_frame_plt
));
970 /* Copy the extra info we tack onto an elf_link_hash_entry. */
973 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
974 struct elf_link_hash_entry
*dir
,
975 struct elf_link_hash_entry
*ind
)
977 struct elf_i386_link_hash_entry
*edir
, *eind
;
979 edir
= (struct elf_i386_link_hash_entry
*) dir
;
980 eind
= (struct elf_i386_link_hash_entry
*) ind
;
982 if (eind
->dyn_relocs
!= NULL
)
984 if (edir
->dyn_relocs
!= NULL
)
986 struct elf_dyn_relocs
**pp
;
987 struct elf_dyn_relocs
*p
;
989 /* Add reloc counts against the indirect sym to the direct sym
990 list. Merge any entries against the same section. */
991 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
993 struct elf_dyn_relocs
*q
;
995 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
996 if (q
->sec
== p
->sec
)
998 q
->pc_count
+= p
->pc_count
;
999 q
->count
+= p
->count
;
1006 *pp
= edir
->dyn_relocs
;
1009 edir
->dyn_relocs
= eind
->dyn_relocs
;
1010 eind
->dyn_relocs
= NULL
;
1013 if (ind
->root
.type
== bfd_link_hash_indirect
1014 && dir
->got
.refcount
<= 0)
1016 edir
->tls_type
= eind
->tls_type
;
1017 eind
->tls_type
= GOT_UNKNOWN
;
1020 if (ELIMINATE_COPY_RELOCS
1021 && ind
->root
.type
!= bfd_link_hash_indirect
1022 && dir
->dynamic_adjusted
)
1024 /* If called to transfer flags for a weakdef during processing
1025 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1026 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1027 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1028 dir
->ref_regular
|= ind
->ref_regular
;
1029 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1030 dir
->needs_plt
|= ind
->needs_plt
;
1031 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1034 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1044 /* Return TRUE if the TLS access code sequence support transition
1048 elf_i386_check_tls_transition (bfd
*abfd
, asection
*sec
,
1050 Elf_Internal_Shdr
*symtab_hdr
,
1051 struct elf_link_hash_entry
**sym_hashes
,
1052 unsigned int r_type
,
1053 const Elf_Internal_Rela
*rel
,
1054 const Elf_Internal_Rela
*relend
)
1056 unsigned int val
, type
;
1057 unsigned long r_symndx
;
1058 struct elf_link_hash_entry
*h
;
1061 /* Get the section contents. */
1062 if (contents
== NULL
)
1064 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1065 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1068 /* FIXME: How to better handle error condition? */
1069 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1072 /* Cache the section contents for elf_link_input_bfd. */
1073 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1077 offset
= rel
->r_offset
;
1082 if (offset
< 2 || (rel
+ 1) >= relend
)
1085 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1086 if (r_type
== R_386_TLS_GD
)
1088 /* Check transition from GD access model. Only
1089 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1090 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1091 can transit to different access model. */
1092 if ((offset
+ 10) > sec
->size
||
1093 (type
!= 0x8d && type
!= 0x04))
1096 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1099 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1103 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
1106 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
1111 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1112 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1115 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1121 /* Check transition from LD access model. Only
1122 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1123 can transit to different access model. */
1124 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1127 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1128 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1132 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1135 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1136 if (r_symndx
< symtab_hdr
->sh_info
)
1139 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1140 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1141 may be versioned. */
1143 && h
->root
.root
.string
!= NULL
1144 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1145 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1146 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1150 /* Check transition from IE access model:
1151 movl foo@indntpoff(%rip), %eax
1152 movl foo@indntpoff(%rip), %reg
1153 addl foo@indntpoff(%rip), %reg
1156 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1159 /* Check "movl foo@tpoff(%rip), %eax" first. */
1160 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1167 /* Check movl|addl foo@tpoff(%rip), %reg. */
1168 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1169 return ((type
== 0x8b || type
== 0x03)
1170 && (val
& 0xc7) == 0x05);
1172 case R_386_TLS_GOTIE
:
1173 case R_386_TLS_IE_32
:
1174 /* Check transition from {IE_32,GOTIE} access model:
1175 subl foo@{tpoff,gontoff}(%reg1), %reg2
1176 movl foo@{tpoff,gontoff}(%reg1), %reg2
1177 addl foo@{tpoff,gontoff}(%reg1), %reg2
1180 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1183 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1184 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1187 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1188 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1190 case R_386_TLS_GOTDESC
:
1191 /* Check transition from GDesc access model:
1192 leal x@tlsdesc(%ebx), %eax
1194 Make sure it's a leal adding ebx to a 32-bit offset
1195 into any register, although it's probably almost always
1198 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1201 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1204 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1205 return (val
& 0xc7) == 0x83;
1207 case R_386_TLS_DESC_CALL
:
1208 /* Check transition from GDesc access model:
1209 call *x@tlsdesc(%rax)
1211 if (offset
+ 2 <= sec
->size
)
1213 /* Make sure that it's a call *x@tlsdesc(%rax). */
1214 static i386_opcode16 call
= { { 0xff, 0x10 } };
1215 return bfd_get_16 (abfd
, contents
+ offset
) == call
.i
;
1225 /* Return TRUE if the TLS access transition is OK or no transition
1226 will be performed. Update R_TYPE if there is a transition. */
1229 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1230 asection
*sec
, bfd_byte
*contents
,
1231 Elf_Internal_Shdr
*symtab_hdr
,
1232 struct elf_link_hash_entry
**sym_hashes
,
1233 unsigned int *r_type
, int tls_type
,
1234 const Elf_Internal_Rela
*rel
,
1235 const Elf_Internal_Rela
*relend
,
1236 struct elf_link_hash_entry
*h
,
1237 unsigned long r_symndx
)
1239 unsigned int from_type
= *r_type
;
1240 unsigned int to_type
= from_type
;
1241 bfd_boolean check
= TRUE
;
1243 /* Skip TLS transition for functions. */
1245 && (h
->type
== STT_FUNC
1246 || h
->type
== STT_GNU_IFUNC
))
1252 case R_386_TLS_GOTDESC
:
1253 case R_386_TLS_DESC_CALL
:
1254 case R_386_TLS_IE_32
:
1256 case R_386_TLS_GOTIE
:
1257 if (info
->executable
)
1260 to_type
= R_386_TLS_LE_32
;
1261 else if (from_type
!= R_386_TLS_IE
1262 && from_type
!= R_386_TLS_GOTIE
)
1263 to_type
= R_386_TLS_IE_32
;
1266 /* When we are called from elf_i386_relocate_section, CONTENTS
1267 isn't NULL and there may be additional transitions based on
1269 if (contents
!= NULL
)
1271 unsigned int new_to_type
= to_type
;
1273 if (info
->executable
1276 && (tls_type
& GOT_TLS_IE
))
1277 new_to_type
= R_386_TLS_LE_32
;
1279 if (to_type
== R_386_TLS_GD
1280 || to_type
== R_386_TLS_GOTDESC
1281 || to_type
== R_386_TLS_DESC_CALL
)
1283 if (tls_type
== GOT_TLS_IE_POS
)
1284 new_to_type
= R_386_TLS_GOTIE
;
1285 else if (tls_type
& GOT_TLS_IE
)
1286 new_to_type
= R_386_TLS_IE_32
;
1289 /* We checked the transition before when we were called from
1290 elf_i386_check_relocs. We only want to check the new
1291 transition which hasn't been checked before. */
1292 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1293 to_type
= new_to_type
;
1299 if (info
->executable
)
1300 to_type
= R_386_TLS_LE_32
;
1307 /* Return TRUE if there is no transition. */
1308 if (from_type
== to_type
)
1311 /* Check if the transition can be performed. */
1313 && ! elf_i386_check_tls_transition (abfd
, sec
, contents
,
1314 symtab_hdr
, sym_hashes
,
1315 from_type
, rel
, relend
))
1317 reloc_howto_type
*from
, *to
;
1320 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1321 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1324 name
= h
->root
.root
.string
;
1327 struct elf_i386_link_hash_table
*htab
;
1329 htab
= elf_i386_hash_table (info
);
1334 Elf_Internal_Sym
*isym
;
1336 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1338 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1342 (*_bfd_error_handler
)
1343 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1344 "in section `%A' failed"),
1345 abfd
, sec
, from
->name
, to
->name
, name
,
1346 (unsigned long) rel
->r_offset
);
1347 bfd_set_error (bfd_error_bad_value
);
1355 /* Look through the relocs for a section during the first phase, and
1356 calculate needed space in the global offset table, procedure linkage
1357 table, and dynamic reloc sections. */
1360 elf_i386_check_relocs (bfd
*abfd
,
1361 struct bfd_link_info
*info
,
1363 const Elf_Internal_Rela
*relocs
)
1365 struct elf_i386_link_hash_table
*htab
;
1366 Elf_Internal_Shdr
*symtab_hdr
;
1367 struct elf_link_hash_entry
**sym_hashes
;
1368 const Elf_Internal_Rela
*rel
;
1369 const Elf_Internal_Rela
*rel_end
;
1372 if (info
->relocatable
)
1375 BFD_ASSERT (is_i386_elf (abfd
));
1377 htab
= elf_i386_hash_table (info
);
1381 symtab_hdr
= &elf_symtab_hdr (abfd
);
1382 sym_hashes
= elf_sym_hashes (abfd
);
1386 rel_end
= relocs
+ sec
->reloc_count
;
1387 for (rel
= relocs
; rel
< rel_end
; rel
++)
1389 unsigned int r_type
;
1390 unsigned long r_symndx
;
1391 struct elf_link_hash_entry
*h
;
1392 Elf_Internal_Sym
*isym
;
1395 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1396 r_type
= ELF32_R_TYPE (rel
->r_info
);
1398 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1400 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1406 if (r_symndx
< symtab_hdr
->sh_info
)
1408 /* A local symbol. */
1409 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1414 /* Check relocation against local STT_GNU_IFUNC symbol. */
1415 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1417 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1421 /* Fake a STT_GNU_IFUNC symbol. */
1422 h
->type
= STT_GNU_IFUNC
;
1425 h
->forced_local
= 1;
1426 h
->root
.type
= bfd_link_hash_defined
;
1434 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1435 while (h
->root
.type
== bfd_link_hash_indirect
1436 || h
->root
.type
== bfd_link_hash_warning
)
1437 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1442 /* Create the ifunc sections for static executables. If we
1443 never see an indirect function symbol nor we are building
1444 a static executable, those sections will be empty and
1445 won't appear in output. */
1456 if (htab
->elf
.dynobj
== NULL
)
1457 htab
->elf
.dynobj
= abfd
;
1458 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1463 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1464 it here if it is defined in a non-shared object. */
1465 if (h
->type
== STT_GNU_IFUNC
1468 /* It is referenced by a non-shared object. */
1472 /* STT_GNU_IFUNC symbol must go through PLT. */
1473 h
->plt
.refcount
+= 1;
1475 /* STT_GNU_IFUNC needs dynamic sections. */
1476 if (htab
->elf
.dynobj
== NULL
)
1477 htab
->elf
.dynobj
= abfd
;
1482 if (h
->root
.root
.string
)
1483 name
= h
->root
.root
.string
;
1485 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1487 (*_bfd_error_handler
)
1488 (_("%B: relocation %s against STT_GNU_IFUNC "
1489 "symbol `%s' isn't handled by %s"), abfd
,
1490 elf_howto_table
[r_type
].name
,
1491 name
, __FUNCTION__
);
1492 bfd_set_error (bfd_error_bad_value
);
1497 h
->pointer_equality_needed
= 1;
1500 /* We must copy these reloc types into the
1501 output file. Create a reloc section in
1502 dynobj and make room for this reloc. */
1503 sreloc
= _bfd_elf_create_ifunc_dyn_reloc
1504 (abfd
, info
, sec
, sreloc
,
1505 &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
);
1520 h
->got
.refcount
+= 1;
1521 if (htab
->elf
.sgot
== NULL
1522 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1532 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1533 symtab_hdr
, sym_hashes
,
1534 &r_type
, GOT_UNKNOWN
,
1535 rel
, rel_end
, h
, r_symndx
))
1541 htab
->tls_ldm_got
.refcount
+= 1;
1545 /* This symbol requires a procedure linkage table entry. We
1546 actually build the entry in adjust_dynamic_symbol,
1547 because this might be a case of linking PIC code which is
1548 never referenced by a dynamic object, in which case we
1549 don't need to generate a procedure linkage table entry
1552 /* If this is a local symbol, we resolve it directly without
1553 creating a procedure linkage table entry. */
1558 h
->plt
.refcount
+= 1;
1561 case R_386_TLS_IE_32
:
1563 case R_386_TLS_GOTIE
:
1564 if (!info
->executable
)
1565 info
->flags
|= DF_STATIC_TLS
;
1570 case R_386_TLS_GOTDESC
:
1571 case R_386_TLS_DESC_CALL
:
1572 /* This symbol requires a global offset table entry. */
1574 int tls_type
, old_tls_type
;
1579 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1580 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1581 case R_386_TLS_GOTDESC
:
1582 case R_386_TLS_DESC_CALL
:
1583 tls_type
= GOT_TLS_GDESC
; break;
1584 case R_386_TLS_IE_32
:
1585 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1586 tls_type
= GOT_TLS_IE_NEG
;
1588 /* If this is a GD->IE transition, we may use either of
1589 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1590 tls_type
= GOT_TLS_IE
;
1593 case R_386_TLS_GOTIE
:
1594 tls_type
= GOT_TLS_IE_POS
; break;
1599 h
->got
.refcount
+= 1;
1600 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1604 bfd_signed_vma
*local_got_refcounts
;
1606 /* This is a global offset table entry for a local symbol. */
1607 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1608 if (local_got_refcounts
== NULL
)
1612 size
= symtab_hdr
->sh_info
;
1613 size
*= (sizeof (bfd_signed_vma
)
1614 + sizeof (bfd_vma
) + sizeof(char));
1615 local_got_refcounts
= (bfd_signed_vma
*)
1616 bfd_zalloc (abfd
, size
);
1617 if (local_got_refcounts
== NULL
)
1619 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1620 elf_i386_local_tlsdesc_gotent (abfd
)
1621 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1622 elf_i386_local_got_tls_type (abfd
)
1623 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1625 local_got_refcounts
[r_symndx
] += 1;
1626 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1629 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1630 tls_type
|= old_tls_type
;
1631 /* If a TLS symbol is accessed using IE at least once,
1632 there is no point to use dynamic model for it. */
1633 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1634 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1635 || (tls_type
& GOT_TLS_IE
) == 0))
1637 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1638 tls_type
= old_tls_type
;
1639 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1640 && GOT_TLS_GD_ANY_P (tls_type
))
1641 tls_type
|= old_tls_type
;
1645 name
= h
->root
.root
.string
;
1647 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1649 (*_bfd_error_handler
)
1650 (_("%B: `%s' accessed both as normal and "
1651 "thread local symbol"),
1657 if (old_tls_type
!= tls_type
)
1660 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1662 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1670 if (htab
->elf
.sgot
== NULL
)
1672 if (htab
->elf
.dynobj
== NULL
)
1673 htab
->elf
.dynobj
= abfd
;
1674 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
1677 if (r_type
!= R_386_TLS_IE
)
1681 case R_386_TLS_LE_32
:
1683 if (info
->executable
)
1685 info
->flags
|= DF_STATIC_TLS
;
1690 if (h
!= NULL
&& info
->executable
)
1692 /* If this reloc is in a read-only section, we might
1693 need a copy reloc. We can't check reliably at this
1694 stage whether the section is read-only, as input
1695 sections have not yet been mapped to output sections.
1696 Tentatively set the flag for now, and correct in
1697 adjust_dynamic_symbol. */
1700 /* We may need a .plt entry if the function this reloc
1701 refers to is in a shared lib. */
1702 h
->plt
.refcount
+= 1;
1703 if (r_type
!= R_386_PC32
)
1704 h
->pointer_equality_needed
= 1;
1707 /* If we are creating a shared library, and this is a reloc
1708 against a global symbol, or a non PC relative reloc
1709 against a local symbol, then we need to copy the reloc
1710 into the shared library. However, if we are linking with
1711 -Bsymbolic, we do not need to copy a reloc against a
1712 global symbol which is defined in an object we are
1713 including in the link (i.e., DEF_REGULAR is set). At
1714 this point we have not seen all the input files, so it is
1715 possible that DEF_REGULAR is not set now but will be set
1716 later (it is never cleared). In case of a weak definition,
1717 DEF_REGULAR may be cleared later by a strong definition in
1718 a shared library. We account for that possibility below by
1719 storing information in the relocs_copied field of the hash
1720 table entry. A similar situation occurs when creating
1721 shared libraries and symbol visibility changes render the
1724 If on the other hand, we are creating an executable, we
1725 may need to keep relocations for symbols satisfied by a
1726 dynamic library if we manage to avoid copy relocs for the
1729 && (sec
->flags
& SEC_ALLOC
) != 0
1730 && (r_type
!= R_386_PC32
1732 && (! SYMBOLIC_BIND (info
, h
)
1733 || h
->root
.type
== bfd_link_hash_defweak
1734 || !h
->def_regular
))))
1735 || (ELIMINATE_COPY_RELOCS
1737 && (sec
->flags
& SEC_ALLOC
) != 0
1739 && (h
->root
.type
== bfd_link_hash_defweak
1740 || !h
->def_regular
)))
1742 struct elf_dyn_relocs
*p
;
1743 struct elf_dyn_relocs
**head
;
1745 /* We must copy these reloc types into the output file.
1746 Create a reloc section in dynobj and make room for
1750 if (htab
->elf
.dynobj
== NULL
)
1751 htab
->elf
.dynobj
= abfd
;
1753 sreloc
= _bfd_elf_make_dynamic_reloc_section
1754 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1760 /* If this is a global symbol, we count the number of
1761 relocations we need for this symbol. */
1764 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1768 /* Track dynamic relocs needed for local syms too.
1769 We really need local syms available to do this
1774 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1779 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1783 vpp
= &elf_section_data (s
)->local_dynrel
;
1784 head
= (struct elf_dyn_relocs
**)vpp
;
1788 if (p
== NULL
|| p
->sec
!= sec
)
1790 bfd_size_type amt
= sizeof *p
;
1791 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
1803 if (r_type
== R_386_PC32
)
1808 /* This relocation describes the C++ object vtable hierarchy.
1809 Reconstruct it for later use during GC. */
1810 case R_386_GNU_VTINHERIT
:
1811 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1815 /* This relocation describes which C++ vtable entries are actually
1816 used. Record for later use during GC. */
1817 case R_386_GNU_VTENTRY
:
1818 BFD_ASSERT (h
!= NULL
);
1820 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1832 /* Return the section that should be marked against GC for a given
1836 elf_i386_gc_mark_hook (asection
*sec
,
1837 struct bfd_link_info
*info
,
1838 Elf_Internal_Rela
*rel
,
1839 struct elf_link_hash_entry
*h
,
1840 Elf_Internal_Sym
*sym
)
1843 switch (ELF32_R_TYPE (rel
->r_info
))
1845 case R_386_GNU_VTINHERIT
:
1846 case R_386_GNU_VTENTRY
:
1850 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1853 /* Update the got entry reference counts for the section being removed. */
1856 elf_i386_gc_sweep_hook (bfd
*abfd
,
1857 struct bfd_link_info
*info
,
1859 const Elf_Internal_Rela
*relocs
)
1861 struct elf_i386_link_hash_table
*htab
;
1862 Elf_Internal_Shdr
*symtab_hdr
;
1863 struct elf_link_hash_entry
**sym_hashes
;
1864 bfd_signed_vma
*local_got_refcounts
;
1865 const Elf_Internal_Rela
*rel
, *relend
;
1867 if (info
->relocatable
)
1870 htab
= elf_i386_hash_table (info
);
1874 elf_section_data (sec
)->local_dynrel
= NULL
;
1876 symtab_hdr
= &elf_symtab_hdr (abfd
);
1877 sym_hashes
= elf_sym_hashes (abfd
);
1878 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1880 relend
= relocs
+ sec
->reloc_count
;
1881 for (rel
= relocs
; rel
< relend
; rel
++)
1883 unsigned long r_symndx
;
1884 unsigned int r_type
;
1885 struct elf_link_hash_entry
*h
= NULL
;
1887 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1888 if (r_symndx
>= symtab_hdr
->sh_info
)
1890 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1891 while (h
->root
.type
== bfd_link_hash_indirect
1892 || h
->root
.type
== bfd_link_hash_warning
)
1893 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1897 /* A local symbol. */
1898 Elf_Internal_Sym
*isym
;
1900 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1903 /* Check relocation against local STT_GNU_IFUNC symbol. */
1905 && ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1907 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1915 struct elf_i386_link_hash_entry
*eh
;
1916 struct elf_dyn_relocs
**pp
;
1917 struct elf_dyn_relocs
*p
;
1919 eh
= (struct elf_i386_link_hash_entry
*) h
;
1920 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1923 /* Everything must go for SEC. */
1929 r_type
= ELF32_R_TYPE (rel
->r_info
);
1930 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1931 symtab_hdr
, sym_hashes
,
1932 &r_type
, GOT_UNKNOWN
,
1933 rel
, relend
, h
, r_symndx
))
1939 if (htab
->tls_ldm_got
.refcount
> 0)
1940 htab
->tls_ldm_got
.refcount
-= 1;
1944 case R_386_TLS_GOTDESC
:
1945 case R_386_TLS_DESC_CALL
:
1946 case R_386_TLS_IE_32
:
1948 case R_386_TLS_GOTIE
:
1952 if (h
->got
.refcount
> 0)
1953 h
->got
.refcount
-= 1;
1954 if (h
->type
== STT_GNU_IFUNC
)
1956 if (h
->plt
.refcount
> 0)
1957 h
->plt
.refcount
-= 1;
1960 else if (local_got_refcounts
!= NULL
)
1962 if (local_got_refcounts
[r_symndx
] > 0)
1963 local_got_refcounts
[r_symndx
] -= 1;
1970 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
1977 if (h
->plt
.refcount
> 0)
1978 h
->plt
.refcount
-= 1;
1983 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
1985 if (h
->got
.refcount
> 0)
1986 h
->got
.refcount
-= 1;
1987 if (h
->plt
.refcount
> 0)
1988 h
->plt
.refcount
-= 1;
2000 /* Adjust a symbol defined by a dynamic object and referenced by a
2001 regular object. The current definition is in some section of the
2002 dynamic object, but we're not including those sections. We have to
2003 change the definition to something the rest of the link can
2007 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2008 struct elf_link_hash_entry
*h
)
2010 struct elf_i386_link_hash_table
*htab
;
2013 /* STT_GNU_IFUNC symbol must go through PLT. */
2014 if (h
->type
== STT_GNU_IFUNC
)
2016 if (h
->plt
.refcount
<= 0)
2018 h
->plt
.offset
= (bfd_vma
) -1;
2024 /* If this is a function, put it in the procedure linkage table. We
2025 will fill in the contents of the procedure linkage table later,
2026 when we know the address of the .got section. */
2027 if (h
->type
== STT_FUNC
2030 if (h
->plt
.refcount
<= 0
2031 || SYMBOL_CALLS_LOCAL (info
, h
)
2032 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2033 && h
->root
.type
== bfd_link_hash_undefweak
))
2035 /* This case can occur if we saw a PLT32 reloc in an input
2036 file, but the symbol was never referred to by a dynamic
2037 object, or if all references were garbage collected. In
2038 such a case, we don't actually need to build a procedure
2039 linkage table, and we can just do a PC32 reloc instead. */
2040 h
->plt
.offset
= (bfd_vma
) -1;
2047 /* It's possible that we incorrectly decided a .plt reloc was
2048 needed for an R_386_PC32 reloc to a non-function sym in
2049 check_relocs. We can't decide accurately between function and
2050 non-function syms in check-relocs; Objects loaded later in
2051 the link may change h->type. So fix it now. */
2052 h
->plt
.offset
= (bfd_vma
) -1;
2054 /* If this is a weak symbol, and there is a real definition, the
2055 processor independent code will have arranged for us to see the
2056 real definition first, and we can just use the same value. */
2057 if (h
->u
.weakdef
!= NULL
)
2059 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2060 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2061 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2062 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2063 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2064 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2068 /* This is a reference to a symbol defined by a dynamic object which
2069 is not a function. */
2071 /* If we are creating a shared library, we must presume that the
2072 only references to the symbol are via the global offset table.
2073 For such cases we need not do anything here; the relocations will
2074 be handled correctly by relocate_section. */
2078 /* If there are no references to this symbol that do not use the
2079 GOT, we don't need to generate a copy reloc. */
2080 if (!h
->non_got_ref
)
2083 /* If -z nocopyreloc was given, we won't generate them either. */
2084 if (info
->nocopyreloc
)
2090 htab
= elf_i386_hash_table (info
);
2094 /* If there aren't any dynamic relocs in read-only sections, then
2095 we can keep the dynamic relocs and avoid the copy reloc. This
2096 doesn't work on VxWorks, where we can not have dynamic relocations
2097 (other than copy and jump slot relocations) in an executable. */
2098 if (ELIMINATE_COPY_RELOCS
2099 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2101 struct elf_i386_link_hash_entry
* eh
;
2102 struct elf_dyn_relocs
*p
;
2104 eh
= (struct elf_i386_link_hash_entry
*) h
;
2105 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2107 s
= p
->sec
->output_section
;
2108 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2121 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
2122 h
->root
.root
.string
);
2126 /* We must allocate the symbol in our .dynbss section, which will
2127 become part of the .bss section of the executable. There will be
2128 an entry for this symbol in the .dynsym section. The dynamic
2129 object will contain position independent code, so all references
2130 from the dynamic object to this symbol will go through the global
2131 offset table. The dynamic linker will use the .dynsym entry to
2132 determine the address it must put in the global offset table, so
2133 both the dynamic object and the regular object will refer to the
2134 same memory location for the variable. */
2136 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2137 copy the initial value out of the dynamic object and into the
2138 runtime process image. */
2139 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2141 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2147 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2150 /* Allocate space in .plt, .got and associated reloc sections for
2154 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2156 struct bfd_link_info
*info
;
2157 struct elf_i386_link_hash_table
*htab
;
2158 struct elf_i386_link_hash_entry
*eh
;
2159 struct elf_dyn_relocs
*p
;
2161 if (h
->root
.type
== bfd_link_hash_indirect
)
2164 eh
= (struct elf_i386_link_hash_entry
*) h
;
2166 info
= (struct bfd_link_info
*) inf
;
2167 htab
= elf_i386_hash_table (info
);
2171 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2172 here if it is defined and referenced in a non-shared object. */
2173 if (h
->type
== STT_GNU_IFUNC
2175 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2178 else if (htab
->elf
.dynamic_sections_created
2179 && h
->plt
.refcount
> 0)
2181 /* Make sure this symbol is output as a dynamic symbol.
2182 Undefined weak syms won't yet be marked as dynamic. */
2183 if (h
->dynindx
== -1
2184 && !h
->forced_local
)
2186 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2191 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2193 asection
*s
= htab
->elf
.splt
;
2195 /* If this is the first .plt entry, make room for the special
2198 s
->size
+= PLT_ENTRY_SIZE
;
2200 h
->plt
.offset
= s
->size
;
2202 /* If this symbol is not defined in a regular file, and we are
2203 not generating a shared library, then set the symbol to this
2204 location in the .plt. This is required to make function
2205 pointers compare as equal between the normal executable and
2206 the shared library. */
2210 h
->root
.u
.def
.section
= s
;
2211 h
->root
.u
.def
.value
= h
->plt
.offset
;
2214 /* Make room for this entry. */
2215 s
->size
+= PLT_ENTRY_SIZE
;
2217 /* We also need to make an entry in the .got.plt section, which
2218 will be placed in the .got section by the linker script. */
2219 htab
->elf
.sgotplt
->size
+= 4;
2221 /* We also need to make an entry in the .rel.plt section. */
2222 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2223 htab
->next_tls_desc_index
++;
2225 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2228 /* VxWorks has a second set of relocations for each PLT entry
2229 in executables. They go in a separate relocation section,
2230 which is processed by the kernel loader. */
2232 /* There are two relocations for the initial PLT entry: an
2233 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2234 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2236 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
2237 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2239 /* There are two extra relocations for each subsequent PLT entry:
2240 an R_386_32 relocation for the GOT entry, and an R_386_32
2241 relocation for the PLT entry. */
2243 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2248 h
->plt
.offset
= (bfd_vma
) -1;
2254 h
->plt
.offset
= (bfd_vma
) -1;
2258 eh
->tlsdesc_got
= (bfd_vma
) -1;
2260 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2261 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2262 if (h
->got
.refcount
> 0
2265 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2266 h
->got
.offset
= (bfd_vma
) -1;
2267 else if (h
->got
.refcount
> 0)
2271 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2273 /* Make sure this symbol is output as a dynamic symbol.
2274 Undefined weak syms won't yet be marked as dynamic. */
2275 if (h
->dynindx
== -1
2276 && !h
->forced_local
)
2278 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2283 if (GOT_TLS_GDESC_P (tls_type
))
2285 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2286 - elf_i386_compute_jump_table_size (htab
);
2287 htab
->elf
.sgotplt
->size
+= 8;
2288 h
->got
.offset
= (bfd_vma
) -2;
2290 if (! GOT_TLS_GDESC_P (tls_type
)
2291 || GOT_TLS_GD_P (tls_type
))
2293 h
->got
.offset
= s
->size
;
2295 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2296 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2299 dyn
= htab
->elf
.dynamic_sections_created
;
2300 /* R_386_TLS_IE_32 needs one dynamic relocation,
2301 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2302 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2303 need two), R_386_TLS_GD needs one if local symbol and two if
2305 if (tls_type
== GOT_TLS_IE_BOTH
)
2306 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2307 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2308 || (tls_type
& GOT_TLS_IE
))
2309 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2310 else if (GOT_TLS_GD_P (tls_type
))
2311 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2312 else if (! GOT_TLS_GDESC_P (tls_type
)
2313 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2314 || h
->root
.type
!= bfd_link_hash_undefweak
)
2316 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2317 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2318 if (GOT_TLS_GDESC_P (tls_type
))
2319 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2322 h
->got
.offset
= (bfd_vma
) -1;
2324 if (eh
->dyn_relocs
== NULL
)
2327 /* In the shared -Bsymbolic case, discard space allocated for
2328 dynamic pc-relative relocs against symbols which turn out to be
2329 defined in regular objects. For the normal shared case, discard
2330 space for pc-relative relocs that have become local due to symbol
2331 visibility changes. */
2335 /* The only reloc that uses pc_count is R_386_PC32, which will
2336 appear on a call or on something like ".long foo - .". We
2337 want calls to protected symbols to resolve directly to the
2338 function rather than going via the plt. If people want
2339 function pointer comparisons to work as expected then they
2340 should avoid writing assembly like ".long foo - .". */
2341 if (SYMBOL_CALLS_LOCAL (info
, h
))
2343 struct elf_dyn_relocs
**pp
;
2345 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2347 p
->count
-= p
->pc_count
;
2356 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2358 struct elf_dyn_relocs
**pp
;
2359 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2361 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2368 /* Also discard relocs on undefined weak syms with non-default
2370 if (eh
->dyn_relocs
!= NULL
2371 && h
->root
.type
== bfd_link_hash_undefweak
)
2373 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2374 eh
->dyn_relocs
= NULL
;
2376 /* Make sure undefined weak symbols are output as a dynamic
2378 else if (h
->dynindx
== -1
2379 && !h
->forced_local
)
2381 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2386 else if (ELIMINATE_COPY_RELOCS
)
2388 /* For the non-shared case, discard space for relocs against
2389 symbols which turn out to need copy relocs or are not
2395 || (htab
->elf
.dynamic_sections_created
2396 && (h
->root
.type
== bfd_link_hash_undefweak
2397 || h
->root
.type
== bfd_link_hash_undefined
))))
2399 /* Make sure this symbol is output as a dynamic symbol.
2400 Undefined weak syms won't yet be marked as dynamic. */
2401 if (h
->dynindx
== -1
2402 && !h
->forced_local
)
2404 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2408 /* If that succeeded, we know we'll be keeping all the
2410 if (h
->dynindx
!= -1)
2414 eh
->dyn_relocs
= NULL
;
2419 /* Finally, allocate space. */
2420 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2424 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2426 BFD_ASSERT (sreloc
!= NULL
);
2427 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2433 /* Allocate space in .plt, .got and associated reloc sections for
2434 local dynamic relocs. */
2437 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2439 struct elf_link_hash_entry
*h
2440 = (struct elf_link_hash_entry
*) *slot
;
2442 if (h
->type
!= STT_GNU_IFUNC
2446 || h
->root
.type
!= bfd_link_hash_defined
)
2449 return elf_i386_allocate_dynrelocs (h
, inf
);
2452 /* Find any dynamic relocs that apply to read-only sections. */
2455 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2457 struct elf_i386_link_hash_entry
*eh
;
2458 struct elf_dyn_relocs
*p
;
2460 /* Skip local IFUNC symbols. */
2461 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2464 eh
= (struct elf_i386_link_hash_entry
*) h
;
2465 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2467 asection
*s
= p
->sec
->output_section
;
2469 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2471 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2473 info
->flags
|= DF_TEXTREL
;
2475 if (info
->warn_shared_textrel
&& info
->shared
)
2476 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2477 p
->sec
->owner
, h
->root
.root
.string
,
2480 /* Not an error, just cut short the traversal. */
2487 /* Set the sizes of the dynamic sections. */
2490 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2492 struct elf_i386_link_hash_table
*htab
;
2498 htab
= elf_i386_hash_table (info
);
2501 dynobj
= htab
->elf
.dynobj
;
2505 if (htab
->elf
.dynamic_sections_created
)
2507 /* Set the contents of the .interp section to the interpreter. */
2508 if (info
->executable
)
2510 s
= bfd_get_section_by_name (dynobj
, ".interp");
2513 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2514 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2518 /* Set up .got offsets for local syms, and space for local dynamic
2520 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2522 bfd_signed_vma
*local_got
;
2523 bfd_signed_vma
*end_local_got
;
2524 char *local_tls_type
;
2525 bfd_vma
*local_tlsdesc_gotent
;
2526 bfd_size_type locsymcount
;
2527 Elf_Internal_Shdr
*symtab_hdr
;
2530 if (! is_i386_elf (ibfd
))
2533 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2535 struct elf_dyn_relocs
*p
;
2537 for (p
= ((struct elf_dyn_relocs
*)
2538 elf_section_data (s
)->local_dynrel
);
2542 if (!bfd_is_abs_section (p
->sec
)
2543 && bfd_is_abs_section (p
->sec
->output_section
))
2545 /* Input section has been discarded, either because
2546 it is a copy of a linkonce section or due to
2547 linker script /DISCARD/, so we'll be discarding
2550 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
2551 && strcmp (p
->sec
->output_section
->name
,
2554 /* Relocations in vxworks .tls_vars sections are
2555 handled specially by the loader. */
2557 else if (p
->count
!= 0)
2559 srel
= elf_section_data (p
->sec
)->sreloc
;
2560 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2561 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2562 && (info
->flags
& DF_TEXTREL
) == 0)
2564 info
->flags
|= DF_TEXTREL
;
2565 if (info
->warn_shared_textrel
&& info
->shared
)
2566 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2567 p
->sec
->owner
, p
->sec
);
2573 local_got
= elf_local_got_refcounts (ibfd
);
2577 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2578 locsymcount
= symtab_hdr
->sh_info
;
2579 end_local_got
= local_got
+ locsymcount
;
2580 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
2581 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
2583 srel
= htab
->elf
.srelgot
;
2584 for (; local_got
< end_local_got
;
2585 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2587 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2590 if (GOT_TLS_GDESC_P (*local_tls_type
))
2592 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2593 - elf_i386_compute_jump_table_size (htab
);
2594 htab
->elf
.sgotplt
->size
+= 8;
2595 *local_got
= (bfd_vma
) -2;
2597 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2598 || GOT_TLS_GD_P (*local_tls_type
))
2600 *local_got
= s
->size
;
2602 if (GOT_TLS_GD_P (*local_tls_type
)
2603 || *local_tls_type
== GOT_TLS_IE_BOTH
)
2607 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2608 || (*local_tls_type
& GOT_TLS_IE
))
2610 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
2611 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
2612 else if (GOT_TLS_GD_P (*local_tls_type
)
2613 || ! GOT_TLS_GDESC_P (*local_tls_type
))
2614 srel
->size
+= sizeof (Elf32_External_Rel
);
2615 if (GOT_TLS_GDESC_P (*local_tls_type
))
2616 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2620 *local_got
= (bfd_vma
) -1;
2624 if (htab
->tls_ldm_got
.refcount
> 0)
2626 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2628 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
2629 htab
->elf
.sgot
->size
+= 8;
2630 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2633 htab
->tls_ldm_got
.offset
= -1;
2635 /* Allocate global sym .plt and .got entries, and space for global
2636 sym dynamic relocs. */
2637 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
2639 /* Allocate .plt and .got entries, and space for local symbols. */
2640 htab_traverse (htab
->loc_hash_table
,
2641 elf_i386_allocate_local_dynrelocs
,
2644 /* For every jump slot reserved in the sgotplt, reloc_count is
2645 incremented. However, when we reserve space for TLS descriptors,
2646 it's not incremented, so in order to compute the space reserved
2647 for them, it suffices to multiply the reloc count by the jump
2649 if (htab
->elf
.srelplt
)
2650 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
2652 if (htab
->elf
.sgotplt
)
2654 struct elf_link_hash_entry
*got
;
2655 got
= elf_link_hash_lookup (elf_hash_table (info
),
2656 "_GLOBAL_OFFSET_TABLE_",
2657 FALSE
, FALSE
, FALSE
);
2659 /* Don't allocate .got.plt section if there are no GOT nor PLT
2660 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2662 || !got
->ref_regular_nonweak
)
2663 && (htab
->elf
.sgotplt
->size
2664 == get_elf_backend_data (output_bfd
)->got_header_size
)
2665 && (htab
->elf
.splt
== NULL
2666 || htab
->elf
.splt
->size
== 0)
2667 && (htab
->elf
.sgot
== NULL
2668 || htab
->elf
.sgot
->size
== 0)
2669 && (htab
->elf
.iplt
== NULL
2670 || htab
->elf
.iplt
->size
== 0)
2671 && (htab
->elf
.igotplt
== NULL
2672 || htab
->elf
.igotplt
->size
== 0))
2673 htab
->elf
.sgotplt
->size
= 0;
2676 /* We now have determined the sizes of the various dynamic sections.
2677 Allocate memory for them. */
2679 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2681 bfd_boolean strip_section
= TRUE
;
2683 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2686 if (s
== htab
->elf
.splt
2687 || s
== htab
->elf
.sgot
2688 || s
== htab
->elf
.sgotplt
2689 || s
== htab
->elf
.iplt
2690 || s
== htab
->elf
.igotplt
2691 || s
== htab
->sdynbss
)
2693 /* Strip this section if we don't need it; see the
2695 /* We'd like to strip these sections if they aren't needed, but if
2696 we've exported dynamic symbols from them we must leave them.
2697 It's too late to tell BFD to get rid of the symbols. */
2699 if (htab
->elf
.hplt
!= NULL
)
2700 strip_section
= FALSE
;
2702 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
2705 && s
!= htab
->elf
.srelplt
2706 && s
!= htab
->srelplt2
)
2709 /* We use the reloc_count field as a counter if we need
2710 to copy relocs into the output file. */
2715 /* It's not one of our sections, so don't allocate space. */
2721 /* If we don't need this section, strip it from the
2722 output file. This is mostly to handle .rel.bss and
2723 .rel.plt. We must create both sections in
2724 create_dynamic_sections, because they must be created
2725 before the linker maps input sections to output
2726 sections. The linker does that before
2727 adjust_dynamic_symbol is called, and it is that
2728 function which decides whether anything needs to go
2729 into these sections. */
2731 s
->flags
|= SEC_EXCLUDE
;
2735 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2738 /* Allocate memory for the section contents. We use bfd_zalloc
2739 here in case unused entries are not reclaimed before the
2740 section's contents are written out. This should not happen,
2741 but this way if it does, we get a R_386_NONE reloc instead
2743 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
2744 if (s
->contents
== NULL
)
2748 if (htab
->plt_eh_frame
!= NULL
2749 && htab
->elf
.splt
!= NULL
2750 && htab
->elf
.splt
->size
!= 0
2751 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0)
2752 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
2753 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
2755 if (htab
->elf
.dynamic_sections_created
)
2757 /* Add some entries to the .dynamic section. We fill in the
2758 values later, in elf_i386_finish_dynamic_sections, but we
2759 must add the entries now so that we get the correct size for
2760 the .dynamic section. The DT_DEBUG entry is filled in by the
2761 dynamic linker and used by the debugger. */
2762 #define add_dynamic_entry(TAG, VAL) \
2763 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2765 if (info
->executable
)
2767 if (!add_dynamic_entry (DT_DEBUG
, 0))
2771 if (htab
->elf
.splt
->size
!= 0)
2773 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2774 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2775 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2776 || !add_dynamic_entry (DT_JMPREL
, 0))
2782 if (!add_dynamic_entry (DT_REL
, 0)
2783 || !add_dynamic_entry (DT_RELSZ
, 0)
2784 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2787 /* If any dynamic relocs apply to a read-only section,
2788 then we need a DT_TEXTREL entry. */
2789 if ((info
->flags
& DF_TEXTREL
) == 0)
2790 elf_link_hash_traverse (&htab
->elf
,
2791 elf_i386_readonly_dynrelocs
, info
);
2793 if ((info
->flags
& DF_TEXTREL
) != 0)
2795 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2799 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
2800 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
2803 #undef add_dynamic_entry
2809 elf_i386_always_size_sections (bfd
*output_bfd
,
2810 struct bfd_link_info
*info
)
2812 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2816 struct elf_link_hash_entry
*tlsbase
;
2818 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2819 "_TLS_MODULE_BASE_",
2820 FALSE
, FALSE
, FALSE
);
2822 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2824 struct elf_i386_link_hash_table
*htab
;
2825 struct bfd_link_hash_entry
*bh
= NULL
;
2826 const struct elf_backend_data
*bed
2827 = get_elf_backend_data (output_bfd
);
2829 htab
= elf_i386_hash_table (info
);
2833 if (!(_bfd_generic_link_add_one_symbol
2834 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2835 tls_sec
, 0, NULL
, FALSE
,
2836 bed
->collect
, &bh
)))
2839 htab
->tls_module_base
= bh
;
2841 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2842 tlsbase
->def_regular
= 1;
2843 tlsbase
->other
= STV_HIDDEN
;
2844 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2851 /* Set the correct type for an x86 ELF section. We do this by the
2852 section name, which is a hack, but ought to work. */
2855 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2856 Elf_Internal_Shdr
*hdr
,
2861 name
= bfd_get_section_name (abfd
, sec
);
2863 /* This is an ugly, but unfortunately necessary hack that is
2864 needed when producing EFI binaries on x86. It tells
2865 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2866 containing ELF relocation info. We need this hack in order to
2867 be able to generate ELF binaries that can be translated into
2868 EFI applications (which are essentially COFF objects). Those
2869 files contain a COFF ".reloc" section inside an ELFNN object,
2870 which would normally cause BFD to segfault because it would
2871 attempt to interpret this section as containing relocation
2872 entries for section "oc". With this hack enabled, ".reloc"
2873 will be treated as a normal data section, which will avoid the
2874 segfault. However, you won't be able to create an ELFNN binary
2875 with a section named "oc" that needs relocations, but that's
2876 the kind of ugly side-effects you get when detecting section
2877 types based on their names... In practice, this limitation is
2878 unlikely to bite. */
2879 if (strcmp (name
, ".reloc") == 0)
2880 hdr
->sh_type
= SHT_PROGBITS
;
2885 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2886 executables. Rather than setting it to the beginning of the TLS
2887 section, we have to set it to the end. This function may be called
2888 multiple times, it is idempotent. */
2891 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
2893 struct elf_i386_link_hash_table
*htab
;
2894 struct bfd_link_hash_entry
*base
;
2896 if (!info
->executable
)
2899 htab
= elf_i386_hash_table (info
);
2903 base
= htab
->tls_module_base
;
2907 base
->u
.def
.value
= htab
->elf
.tls_size
;
2910 /* Return the base VMA address which should be subtracted from real addresses
2911 when resolving @dtpoff relocation.
2912 This is PT_TLS segment p_vaddr. */
2915 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
2917 /* If tls_sec is NULL, we should have signalled an error already. */
2918 if (elf_hash_table (info
)->tls_sec
== NULL
)
2920 return elf_hash_table (info
)->tls_sec
->vma
;
2923 /* Return the relocation value for @tpoff relocation
2924 if STT_TLS virtual address is ADDRESS. */
2927 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2929 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2930 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2931 bfd_vma static_tls_size
;
2933 /* If tls_sec is NULL, we should have signalled an error already. */
2934 if (htab
->tls_sec
== NULL
)
2937 /* Consider special static TLS alignment requirements. */
2938 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2939 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
2942 /* Relocate an i386 ELF section. */
2945 elf_i386_relocate_section (bfd
*output_bfd
,
2946 struct bfd_link_info
*info
,
2948 asection
*input_section
,
2950 Elf_Internal_Rela
*relocs
,
2951 Elf_Internal_Sym
*local_syms
,
2952 asection
**local_sections
)
2954 struct elf_i386_link_hash_table
*htab
;
2955 Elf_Internal_Shdr
*symtab_hdr
;
2956 struct elf_link_hash_entry
**sym_hashes
;
2957 bfd_vma
*local_got_offsets
;
2958 bfd_vma
*local_tlsdesc_gotents
;
2959 Elf_Internal_Rela
*rel
;
2960 Elf_Internal_Rela
*relend
;
2961 bfd_boolean is_vxworks_tls
;
2963 BFD_ASSERT (is_i386_elf (input_bfd
));
2965 htab
= elf_i386_hash_table (info
);
2968 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2969 sym_hashes
= elf_sym_hashes (input_bfd
);
2970 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2971 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2972 /* We have to handle relocations in vxworks .tls_vars sections
2973 specially, because the dynamic loader is 'weird'. */
2974 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
2976 && !strcmp (input_section
->output_section
->name
,
2979 elf_i386_set_tls_module_base (info
);
2982 relend
= relocs
+ input_section
->reloc_count
;
2983 for (; rel
< relend
; rel
++)
2985 unsigned int r_type
;
2986 reloc_howto_type
*howto
;
2987 unsigned long r_symndx
;
2988 struct elf_link_hash_entry
*h
;
2989 Elf_Internal_Sym
*sym
;
2991 bfd_vma off
, offplt
;
2993 bfd_boolean unresolved_reloc
;
2994 bfd_reloc_status_type r
;
2998 r_type
= ELF32_R_TYPE (rel
->r_info
);
2999 if (r_type
== R_386_GNU_VTINHERIT
3000 || r_type
== R_386_GNU_VTENTRY
)
3003 if ((indx
= r_type
) >= R_386_standard
3004 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3005 >= R_386_ext
- R_386_standard
)
3006 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3007 >= R_386_irelative
- R_386_ext
))
3009 (*_bfd_error_handler
)
3010 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3011 input_bfd
, input_section
, r_type
);
3012 bfd_set_error (bfd_error_bad_value
);
3015 howto
= elf_howto_table
+ indx
;
3017 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3021 unresolved_reloc
= FALSE
;
3022 if (r_symndx
< symtab_hdr
->sh_info
)
3024 sym
= local_syms
+ r_symndx
;
3025 sec
= local_sections
[r_symndx
];
3026 relocation
= (sec
->output_section
->vma
3027 + sec
->output_offset
3030 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3031 && ((sec
->flags
& SEC_MERGE
) != 0
3032 || (info
->relocatable
3033 && sec
->output_offset
!= 0)))
3036 bfd_byte
*where
= contents
+ rel
->r_offset
;
3038 switch (howto
->size
)
3041 addend
= bfd_get_8 (input_bfd
, where
);
3042 if (howto
->pc_relative
)
3044 addend
= (addend
^ 0x80) - 0x80;
3049 addend
= bfd_get_16 (input_bfd
, where
);
3050 if (howto
->pc_relative
)
3052 addend
= (addend
^ 0x8000) - 0x8000;
3057 addend
= bfd_get_32 (input_bfd
, where
);
3058 if (howto
->pc_relative
)
3060 addend
= (addend
^ 0x80000000) - 0x80000000;
3068 if (info
->relocatable
)
3069 addend
+= sec
->output_offset
;
3072 asection
*msec
= sec
;
3073 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3075 addend
-= relocation
;
3076 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3079 switch (howto
->size
)
3082 /* FIXME: overflow checks. */
3083 if (howto
->pc_relative
)
3085 bfd_put_8 (input_bfd
, addend
, where
);
3088 if (howto
->pc_relative
)
3090 bfd_put_16 (input_bfd
, addend
, where
);
3093 if (howto
->pc_relative
)
3095 bfd_put_32 (input_bfd
, addend
, where
);
3099 else if (!info
->relocatable
3100 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3102 /* Relocate against local STT_GNU_IFUNC symbol. */
3103 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3108 /* Set STT_GNU_IFUNC symbol value. */
3109 h
->root
.u
.def
.value
= sym
->st_value
;
3110 h
->root
.u
.def
.section
= sec
;
3115 bfd_boolean warned ATTRIBUTE_UNUSED
;
3117 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3118 r_symndx
, symtab_hdr
, sym_hashes
,
3120 unresolved_reloc
, warned
);
3123 if (sec
!= NULL
&& elf_discarded_section (sec
))
3124 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3125 rel
, relend
, howto
, contents
);
3127 if (info
->relocatable
)
3130 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3131 it here if it is defined in a non-shared object. */
3133 && h
->type
== STT_GNU_IFUNC
3136 asection
*plt
, *gotplt
, *base_got
;
3140 if ((input_section
->flags
& SEC_ALLOC
) == 0
3141 || h
->plt
.offset
== (bfd_vma
) -1)
3144 /* STT_GNU_IFUNC symbol must go through PLT. */
3145 if (htab
->elf
.splt
!= NULL
)
3147 plt
= htab
->elf
.splt
;
3148 gotplt
= htab
->elf
.sgotplt
;
3152 plt
= htab
->elf
.iplt
;
3153 gotplt
= htab
->elf
.igotplt
;
3156 relocation
= (plt
->output_section
->vma
3157 + plt
->output_offset
+ h
->plt
.offset
);
3162 if (h
->root
.root
.string
)
3163 name
= h
->root
.root
.string
;
3165 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3167 (*_bfd_error_handler
)
3168 (_("%B: relocation %s against STT_GNU_IFUNC "
3169 "symbol `%s' isn't handled by %s"), input_bfd
,
3170 elf_howto_table
[r_type
].name
,
3171 name
, __FUNCTION__
);
3172 bfd_set_error (bfd_error_bad_value
);
3176 /* Generate dynamic relcoation only when there is a
3177 non-GOF reference in a shared object. */
3178 if (info
->shared
&& h
->non_got_ref
)
3180 Elf_Internal_Rela outrel
;
3185 /* Need a dynamic relocation to get the real function
3187 offset
= _bfd_elf_section_offset (output_bfd
,
3191 if (offset
== (bfd_vma
) -1
3192 || offset
== (bfd_vma
) -2)
3195 outrel
.r_offset
= (input_section
->output_section
->vma
3196 + input_section
->output_offset
3199 if (h
->dynindx
== -1
3201 || info
->executable
)
3203 /* This symbol is resolved locally. */
3204 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3205 bfd_put_32 (output_bfd
,
3206 (h
->root
.u
.def
.value
3207 + h
->root
.u
.def
.section
->output_section
->vma
3208 + h
->root
.u
.def
.section
->output_offset
),
3212 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3214 sreloc
= htab
->elf
.irelifunc
;
3215 loc
= sreloc
->contents
;
3216 loc
+= (sreloc
->reloc_count
++
3217 * sizeof (Elf32_External_Rel
));
3218 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3220 /* If this reloc is against an external symbol, we
3221 do not want to fiddle with the addend. Otherwise,
3222 we need to include the symbol value so that it
3223 becomes an addend for the dynamic reloc. For an
3224 internal symbol, we have updated addend. */
3233 base_got
= htab
->elf
.sgot
;
3234 off
= h
->got
.offset
;
3236 if (base_got
== NULL
)
3239 if (off
== (bfd_vma
) -1)
3241 /* We can't use h->got.offset here to save state, or
3242 even just remember the offset, as finish_dynamic_symbol
3243 would use that as offset into .got. */
3245 if (htab
->elf
.splt
!= NULL
)
3247 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3248 off
= (plt_index
+ 3) * 4;
3249 base_got
= htab
->elf
.sgotplt
;
3253 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3254 off
= plt_index
* 4;
3255 base_got
= htab
->elf
.igotplt
;
3258 if (h
->dynindx
== -1
3262 /* This references the local defitionion. We must
3263 initialize this entry in the global offset table.
3264 Since the offset must always be a multiple of 8,
3265 we use the least significant bit to record
3266 whether we have initialized it already.
3268 When doing a dynamic link, we create a .rela.got
3269 relocation entry to initialize the value. This
3270 is done in the finish_dynamic_symbol routine. */
3275 bfd_put_32 (output_bfd
, relocation
,
3276 base_got
->contents
+ off
);
3283 /* Adjust for static executables. */
3284 if (htab
->elf
.splt
== NULL
)
3285 relocation
+= gotplt
->output_offset
;
3289 relocation
= (base_got
->output_section
->vma
3290 + base_got
->output_offset
+ off
3291 - gotplt
->output_section
->vma
3292 - gotplt
->output_offset
);
3293 /* Adjust for static executables. */
3294 if (htab
->elf
.splt
== NULL
)
3295 relocation
+= gotplt
->output_offset
;
3301 relocation
-= (gotplt
->output_section
->vma
3302 + gotplt
->output_offset
);
3310 /* Relocation is to the entry for this symbol in the global
3312 if (htab
->elf
.sgot
== NULL
)
3319 off
= h
->got
.offset
;
3320 dyn
= htab
->elf
.dynamic_sections_created
;
3321 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3323 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3324 || (ELF_ST_VISIBILITY (h
->other
)
3325 && h
->root
.type
== bfd_link_hash_undefweak
))
3327 /* This is actually a static link, or it is a
3328 -Bsymbolic link and the symbol is defined
3329 locally, or the symbol was forced to be local
3330 because of a version file. We must initialize
3331 this entry in the global offset table. Since the
3332 offset must always be a multiple of 4, we use the
3333 least significant bit to record whether we have
3334 initialized it already.
3336 When doing a dynamic link, we create a .rel.got
3337 relocation entry to initialize the value. This
3338 is done in the finish_dynamic_symbol routine. */
3343 bfd_put_32 (output_bfd
, relocation
,
3344 htab
->elf
.sgot
->contents
+ off
);
3349 unresolved_reloc
= FALSE
;
3353 if (local_got_offsets
== NULL
)
3356 off
= local_got_offsets
[r_symndx
];
3358 /* The offset must always be a multiple of 4. We use
3359 the least significant bit to record whether we have
3360 already generated the necessary reloc. */
3365 bfd_put_32 (output_bfd
, relocation
,
3366 htab
->elf
.sgot
->contents
+ off
);
3371 Elf_Internal_Rela outrel
;
3374 s
= htab
->elf
.srelgot
;
3378 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3379 + htab
->elf
.sgot
->output_offset
3381 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3383 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3384 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3387 local_got_offsets
[r_symndx
] |= 1;
3391 if (off
>= (bfd_vma
) -2)
3394 relocation
= htab
->elf
.sgot
->output_section
->vma
3395 + htab
->elf
.sgot
->output_offset
+ off
3396 - htab
->elf
.sgotplt
->output_section
->vma
3397 - htab
->elf
.sgotplt
->output_offset
;
3401 /* Relocation is relative to the start of the global offset
3404 /* Check to make sure it isn't a protected function symbol
3405 for shared library since it may not be local when used
3406 as function address. We also need to make sure that a
3407 symbol is defined locally. */
3408 if (info
->shared
&& h
)
3410 if (!h
->def_regular
)
3414 switch (ELF_ST_VISIBILITY (h
->other
))
3417 v
= _("hidden symbol");
3420 v
= _("internal symbol");
3423 v
= _("protected symbol");
3430 (*_bfd_error_handler
)
3431 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3432 input_bfd
, v
, h
->root
.root
.string
);
3433 bfd_set_error (bfd_error_bad_value
);
3436 else if (!info
->executable
3437 && h
->type
== STT_FUNC
3438 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3440 (*_bfd_error_handler
)
3441 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3442 input_bfd
, h
->root
.root
.string
);
3443 bfd_set_error (bfd_error_bad_value
);
3448 /* Note that sgot is not involved in this
3449 calculation. We always want the start of .got.plt. If we
3450 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3451 permitted by the ABI, we might have to change this
3453 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3454 + htab
->elf
.sgotplt
->output_offset
;
3458 /* Use global offset table as symbol value. */
3459 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3460 + htab
->elf
.sgotplt
->output_offset
;
3461 unresolved_reloc
= FALSE
;
3465 /* Relocation is to the entry for this symbol in the
3466 procedure linkage table. */
3468 /* Resolve a PLT32 reloc against a local symbol directly,
3469 without using the procedure linkage table. */
3473 if (h
->plt
.offset
== (bfd_vma
) -1
3474 || htab
->elf
.splt
== NULL
)
3476 /* We didn't make a PLT entry for this symbol. This
3477 happens when statically linking PIC code, or when
3478 using -Bsymbolic. */
3482 relocation
= (htab
->elf
.splt
->output_section
->vma
3483 + htab
->elf
.splt
->output_offset
3485 unresolved_reloc
= FALSE
;
3490 if ((input_section
->flags
& SEC_ALLOC
) == 0
3496 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3497 || h
->root
.type
!= bfd_link_hash_undefweak
)
3498 && (r_type
!= R_386_PC32
3499 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3500 || (ELIMINATE_COPY_RELOCS
3507 || h
->root
.type
== bfd_link_hash_undefweak
3508 || h
->root
.type
== bfd_link_hash_undefined
)))
3510 Elf_Internal_Rela outrel
;
3512 bfd_boolean skip
, relocate
;
3515 /* When generating a shared object, these relocations
3516 are copied into the output file to be resolved at run
3523 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3525 if (outrel
.r_offset
== (bfd_vma
) -1)
3527 else if (outrel
.r_offset
== (bfd_vma
) -2)
3528 skip
= TRUE
, relocate
= TRUE
;
3529 outrel
.r_offset
+= (input_section
->output_section
->vma
3530 + input_section
->output_offset
);
3533 memset (&outrel
, 0, sizeof outrel
);
3536 && (r_type
== R_386_PC32
3538 || !SYMBOLIC_BIND (info
, h
)
3539 || !h
->def_regular
))
3540 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3543 /* This symbol is local, or marked to become local. */
3545 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3548 sreloc
= elf_section_data (input_section
)->sreloc
;
3550 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3552 r
= bfd_reloc_notsupported
;
3553 goto check_relocation_error
;
3556 loc
= sreloc
->contents
;
3557 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3559 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3561 /* If this reloc is against an external symbol, we do
3562 not want to fiddle with the addend. Otherwise, we
3563 need to include the symbol value so that it becomes
3564 an addend for the dynamic reloc. */
3571 if (!info
->executable
)
3573 Elf_Internal_Rela outrel
;
3577 outrel
.r_offset
= rel
->r_offset
3578 + input_section
->output_section
->vma
3579 + input_section
->output_offset
;
3580 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3581 sreloc
= elf_section_data (input_section
)->sreloc
;
3584 loc
= sreloc
->contents
;
3585 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3586 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3591 case R_386_TLS_GOTDESC
:
3592 case R_386_TLS_DESC_CALL
:
3593 case R_386_TLS_IE_32
:
3594 case R_386_TLS_GOTIE
:
3595 tls_type
= GOT_UNKNOWN
;
3596 if (h
== NULL
&& local_got_offsets
)
3597 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
3599 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
3600 if (tls_type
== GOT_TLS_IE
)
3601 tls_type
= GOT_TLS_IE_NEG
;
3603 if (! elf_i386_tls_transition (info
, input_bfd
,
3604 input_section
, contents
,
3605 symtab_hdr
, sym_hashes
,
3606 &r_type
, tls_type
, rel
,
3607 relend
, h
, r_symndx
))
3610 if (r_type
== R_386_TLS_LE_32
)
3612 BFD_ASSERT (! unresolved_reloc
);
3613 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3618 /* GD->LE transition. */
3619 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3622 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3624 movl %gs:0, %eax; subl $foo@tpoff, %eax
3625 (6 byte form of subl). */
3626 memcpy (contents
+ rel
->r_offset
- 3,
3627 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3628 roff
= rel
->r_offset
+ 5;
3632 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3634 movl %gs:0, %eax; subl $foo@tpoff, %eax
3635 (6 byte form of subl). */
3636 memcpy (contents
+ rel
->r_offset
- 2,
3637 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3638 roff
= rel
->r_offset
+ 6;
3640 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3642 /* Skip R_386_PC32/R_386_PLT32. */
3646 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3648 /* GDesc -> LE transition.
3649 It's originally something like:
3650 leal x@tlsdesc(%ebx), %eax
3654 Registers other than %eax may be set up here. */
3659 roff
= rel
->r_offset
;
3660 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3662 /* Now modify the instruction as appropriate. */
3663 /* aoliva FIXME: remove the above and xor the byte
3665 bfd_put_8 (output_bfd
, val
^ 0x86,
3666 contents
+ roff
- 1);
3667 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3671 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3673 /* GDesc -> LE transition.
3681 roff
= rel
->r_offset
;
3682 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3683 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3686 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
3690 /* IE->LE transition:
3691 Originally it can be one of:
3699 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3702 /* movl foo, %eax. */
3703 bfd_put_8 (output_bfd
, 0xb8,
3704 contents
+ rel
->r_offset
- 1);
3710 type
= bfd_get_8 (input_bfd
,
3711 contents
+ rel
->r_offset
- 2);
3716 bfd_put_8 (output_bfd
, 0xc7,
3717 contents
+ rel
->r_offset
- 2);
3718 bfd_put_8 (output_bfd
,
3719 0xc0 | ((val
>> 3) & 7),
3720 contents
+ rel
->r_offset
- 1);
3724 bfd_put_8 (output_bfd
, 0x81,
3725 contents
+ rel
->r_offset
- 2);
3726 bfd_put_8 (output_bfd
,
3727 0xc0 | ((val
>> 3) & 7),
3728 contents
+ rel
->r_offset
- 1);
3735 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3736 contents
+ rel
->r_offset
);
3741 unsigned int val
, type
;
3743 /* {IE_32,GOTIE}->LE transition:
3744 Originally it can be one of:
3745 subl foo(%reg1), %reg2
3746 movl foo(%reg1), %reg2
3747 addl foo(%reg1), %reg2
3750 movl $foo, %reg2 (6 byte form)
3751 addl $foo, %reg2. */
3752 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3753 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3757 bfd_put_8 (output_bfd
, 0xc7,
3758 contents
+ rel
->r_offset
- 2);
3759 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3760 contents
+ rel
->r_offset
- 1);
3762 else if (type
== 0x2b)
3765 bfd_put_8 (output_bfd
, 0x81,
3766 contents
+ rel
->r_offset
- 2);
3767 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
3768 contents
+ rel
->r_offset
- 1);
3770 else if (type
== 0x03)
3773 bfd_put_8 (output_bfd
, 0x81,
3774 contents
+ rel
->r_offset
- 2);
3775 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3776 contents
+ rel
->r_offset
- 1);
3780 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
3781 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3782 contents
+ rel
->r_offset
);
3784 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3785 contents
+ rel
->r_offset
);
3790 if (htab
->elf
.sgot
== NULL
)
3795 off
= h
->got
.offset
;
3796 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
3800 if (local_got_offsets
== NULL
)
3803 off
= local_got_offsets
[r_symndx
];
3804 offplt
= local_tlsdesc_gotents
[r_symndx
];
3811 Elf_Internal_Rela outrel
;
3816 if (htab
->elf
.srelgot
== NULL
)
3819 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3821 if (GOT_TLS_GDESC_P (tls_type
))
3823 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
3824 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
3825 <= htab
->elf
.sgotplt
->size
);
3826 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
3827 + htab
->elf
.sgotplt
->output_offset
3829 + htab
->sgotplt_jump_table_size
);
3830 sreloc
= htab
->elf
.srelplt
;
3831 loc
= sreloc
->contents
;
3832 loc
+= (htab
->next_tls_desc_index
++
3833 * sizeof (Elf32_External_Rel
));
3834 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3835 <= sreloc
->contents
+ sreloc
->size
);
3836 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3839 BFD_ASSERT (! unresolved_reloc
);
3840 bfd_put_32 (output_bfd
,
3841 relocation
- elf_i386_dtpoff_base (info
),
3842 htab
->elf
.sgotplt
->contents
+ offplt
3843 + htab
->sgotplt_jump_table_size
+ 4);
3847 bfd_put_32 (output_bfd
, 0,
3848 htab
->elf
.sgotplt
->contents
+ offplt
3849 + htab
->sgotplt_jump_table_size
+ 4);
3853 sreloc
= htab
->elf
.srelgot
;
3855 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3856 + htab
->elf
.sgot
->output_offset
+ off
);
3858 if (GOT_TLS_GD_P (tls_type
))
3859 dr_type
= R_386_TLS_DTPMOD32
;
3860 else if (GOT_TLS_GDESC_P (tls_type
))
3862 else if (tls_type
== GOT_TLS_IE_POS
)
3863 dr_type
= R_386_TLS_TPOFF
;
3865 dr_type
= R_386_TLS_TPOFF32
;
3867 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3868 bfd_put_32 (output_bfd
,
3869 relocation
- elf_i386_dtpoff_base (info
),
3870 htab
->elf
.sgot
->contents
+ off
);
3871 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3872 bfd_put_32 (output_bfd
,
3873 elf_i386_dtpoff_base (info
) - relocation
,
3874 htab
->elf
.sgot
->contents
+ off
);
3875 else if (dr_type
!= R_386_TLS_DESC
)
3876 bfd_put_32 (output_bfd
, 0,
3877 htab
->elf
.sgot
->contents
+ off
);
3878 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3880 loc
= sreloc
->contents
;
3881 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3882 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3883 <= sreloc
->contents
+ sreloc
->size
);
3884 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3886 if (GOT_TLS_GD_P (tls_type
))
3890 BFD_ASSERT (! unresolved_reloc
);
3891 bfd_put_32 (output_bfd
,
3892 relocation
- elf_i386_dtpoff_base (info
),
3893 htab
->elf
.sgot
->contents
+ off
+ 4);
3897 bfd_put_32 (output_bfd
, 0,
3898 htab
->elf
.sgot
->contents
+ off
+ 4);
3899 outrel
.r_info
= ELF32_R_INFO (indx
,
3900 R_386_TLS_DTPOFF32
);
3901 outrel
.r_offset
+= 4;
3902 sreloc
->reloc_count
++;
3903 loc
+= sizeof (Elf32_External_Rel
);
3904 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3905 <= sreloc
->contents
+ sreloc
->size
);
3906 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3909 else if (tls_type
== GOT_TLS_IE_BOTH
)
3911 bfd_put_32 (output_bfd
,
3913 ? relocation
- elf_i386_dtpoff_base (info
)
3915 htab
->elf
.sgot
->contents
+ off
+ 4);
3916 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3917 outrel
.r_offset
+= 4;
3918 sreloc
->reloc_count
++;
3919 loc
+= sizeof (Elf32_External_Rel
);
3920 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3927 local_got_offsets
[r_symndx
] |= 1;
3930 if (off
>= (bfd_vma
) -2
3931 && ! GOT_TLS_GDESC_P (tls_type
))
3933 if (r_type
== R_386_TLS_GOTDESC
3934 || r_type
== R_386_TLS_DESC_CALL
)
3936 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3937 unresolved_reloc
= FALSE
;
3939 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3941 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
3942 + htab
->elf
.sgotplt
->output_offset
;
3943 relocation
= htab
->elf
.sgot
->output_section
->vma
3944 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
3945 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3946 && tls_type
== GOT_TLS_IE_BOTH
)
3948 if (r_type
== R_386_TLS_IE
)
3949 relocation
+= g_o_t
;
3950 unresolved_reloc
= FALSE
;
3952 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3954 unsigned int val
, type
;
3957 /* GD->IE transition. */
3958 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3959 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3962 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3964 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3966 roff
= rel
->r_offset
- 3;
3970 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3972 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3973 roff
= rel
->r_offset
- 2;
3975 memcpy (contents
+ roff
,
3976 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3977 contents
[roff
+ 7] = 0x80 | (val
& 7);
3978 /* If foo is used only with foo@gotntpoff(%reg) and
3979 foo@indntpoff, but not with foo@gottpoff(%reg), change
3980 subl $foo@gottpoff(%reg), %eax
3982 addl $foo@gotntpoff(%reg), %eax. */
3983 if (tls_type
== GOT_TLS_IE_POS
)
3984 contents
[roff
+ 6] = 0x03;
3985 bfd_put_32 (output_bfd
,
3986 htab
->elf
.sgot
->output_section
->vma
3987 + htab
->elf
.sgot
->output_offset
+ off
3988 - htab
->elf
.sgotplt
->output_section
->vma
3989 - htab
->elf
.sgotplt
->output_offset
,
3990 contents
+ roff
+ 8);
3991 /* Skip R_386_PLT32. */
3995 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3997 /* GDesc -> IE transition.
3998 It's originally something like:
3999 leal x@tlsdesc(%ebx), %eax
4002 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4004 movl x@gottpoff(%ebx), %eax # before negl %eax
4006 Registers other than %eax may be set up here. */
4010 /* First, make sure it's a leal adding ebx to a 32-bit
4011 offset into any register, although it's probably
4012 almost always going to be eax. */
4013 roff
= rel
->r_offset
;
4015 /* Now modify the instruction as appropriate. */
4016 /* To turn a leal into a movl in the form we use it, it
4017 suffices to change the first byte from 0x8d to 0x8b.
4018 aoliva FIXME: should we decide to keep the leal, all
4019 we have to do is remove the statement below, and
4020 adjust the relaxation of R_386_TLS_DESC_CALL. */
4021 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4023 if (tls_type
== GOT_TLS_IE_BOTH
)
4026 bfd_put_32 (output_bfd
,
4027 htab
->elf
.sgot
->output_section
->vma
4028 + htab
->elf
.sgot
->output_offset
+ off
4029 - htab
->elf
.sgotplt
->output_section
->vma
4030 - htab
->elf
.sgotplt
->output_offset
,
4034 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4036 /* GDesc -> IE transition.
4044 depending on how we transformed the TLS_GOTDESC above.
4049 roff
= rel
->r_offset
;
4051 /* Now modify the instruction as appropriate. */
4052 if (tls_type
!= GOT_TLS_IE_NEG
)
4055 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4056 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4061 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
4062 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
4072 if (! elf_i386_tls_transition (info
, input_bfd
,
4073 input_section
, contents
,
4074 symtab_hdr
, sym_hashes
,
4075 &r_type
, GOT_UNKNOWN
, rel
,
4076 relend
, h
, r_symndx
))
4079 if (r_type
!= R_386_TLS_LDM
)
4081 /* LD->LE transition:
4082 leal foo(%reg), %eax; call ___tls_get_addr.
4084 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4085 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
4086 memcpy (contents
+ rel
->r_offset
- 2,
4087 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4088 /* Skip R_386_PC32/R_386_PLT32. */
4093 if (htab
->elf
.sgot
== NULL
)
4096 off
= htab
->tls_ldm_got
.offset
;
4101 Elf_Internal_Rela outrel
;
4104 if (htab
->elf
.srelgot
== NULL
)
4107 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4108 + htab
->elf
.sgot
->output_offset
+ off
);
4110 bfd_put_32 (output_bfd
, 0,
4111 htab
->elf
.sgot
->contents
+ off
);
4112 bfd_put_32 (output_bfd
, 0,
4113 htab
->elf
.sgot
->contents
+ off
+ 4);
4114 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
4115 loc
= htab
->elf
.srelgot
->contents
;
4116 loc
+= htab
->elf
.srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4117 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4118 htab
->tls_ldm_got
.offset
|= 1;
4120 relocation
= htab
->elf
.sgot
->output_section
->vma
4121 + htab
->elf
.sgot
->output_offset
+ off
4122 - htab
->elf
.sgotplt
->output_section
->vma
4123 - htab
->elf
.sgotplt
->output_offset
;
4124 unresolved_reloc
= FALSE
;
4127 case R_386_TLS_LDO_32
:
4128 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4129 relocation
-= elf_i386_dtpoff_base (info
);
4131 /* When converting LDO to LE, we must negate. */
4132 relocation
= -elf_i386_tpoff (info
, relocation
);
4135 case R_386_TLS_LE_32
:
4137 if (!info
->executable
)
4139 Elf_Internal_Rela outrel
;
4143 outrel
.r_offset
= rel
->r_offset
4144 + input_section
->output_section
->vma
4145 + input_section
->output_offset
;
4146 if (h
!= NULL
&& h
->dynindx
!= -1)
4150 if (r_type
== R_386_TLS_LE_32
)
4151 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
4153 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4154 sreloc
= elf_section_data (input_section
)->sreloc
;
4157 loc
= sreloc
->contents
;
4158 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4159 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4162 else if (r_type
== R_386_TLS_LE_32
)
4163 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
4165 relocation
-= elf_i386_dtpoff_base (info
);
4167 else if (r_type
== R_386_TLS_LE_32
)
4168 relocation
= elf_i386_tpoff (info
, relocation
);
4170 relocation
= -elf_i386_tpoff (info
, relocation
);
4177 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4178 because such sections are not SEC_ALLOC and thus ld.so will
4179 not process them. */
4180 if (unresolved_reloc
4181 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4184 (*_bfd_error_handler
)
4185 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4188 (long) rel
->r_offset
,
4190 h
->root
.root
.string
);
4195 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4196 contents
, rel
->r_offset
,
4199 check_relocation_error
:
4200 if (r
!= bfd_reloc_ok
)
4205 name
= h
->root
.root
.string
;
4208 name
= bfd_elf_string_from_elf_section (input_bfd
,
4209 symtab_hdr
->sh_link
,
4214 name
= bfd_section_name (input_bfd
, sec
);
4217 if (r
== bfd_reloc_overflow
)
4219 if (! ((*info
->callbacks
->reloc_overflow
)
4220 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4221 (bfd_vma
) 0, input_bfd
, input_section
,
4227 (*_bfd_error_handler
)
4228 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4229 input_bfd
, input_section
,
4230 (long) rel
->r_offset
, name
, (int) r
);
4239 /* Finish up dynamic symbol handling. We set the contents of various
4240 dynamic sections here. */
4243 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
4244 struct bfd_link_info
*info
,
4245 struct elf_link_hash_entry
*h
,
4246 Elf_Internal_Sym
*sym
)
4248 struct elf_i386_link_hash_table
*htab
;
4250 htab
= elf_i386_hash_table (info
);
4254 if (h
->plt
.offset
!= (bfd_vma
) -1)
4258 Elf_Internal_Rela rel
;
4260 asection
*plt
, *gotplt
, *relplt
;
4262 /* When building a static executable, use .iplt, .igot.plt and
4263 .rel.iplt sections for STT_GNU_IFUNC symbols. */
4264 if (htab
->elf
.splt
!= NULL
)
4266 plt
= htab
->elf
.splt
;
4267 gotplt
= htab
->elf
.sgotplt
;
4268 relplt
= htab
->elf
.srelplt
;
4272 plt
= htab
->elf
.iplt
;
4273 gotplt
= htab
->elf
.igotplt
;
4274 relplt
= htab
->elf
.irelplt
;
4277 /* This symbol has an entry in the procedure linkage table. Set
4280 if ((h
->dynindx
== -1
4281 && !((h
->forced_local
|| info
->executable
)
4283 && h
->type
== STT_GNU_IFUNC
))
4289 /* Get the index in the procedure linkage table which
4290 corresponds to this symbol. This is the index of this symbol
4291 in all the symbols for which we are making plt entries. The
4292 first entry in the procedure linkage table is reserved.
4294 Get the offset into the .got table of the entry that
4295 corresponds to this function. Each .got entry is 4 bytes.
4296 The first three are reserved.
4298 For static executables, we don't reserve anything. */
4300 if (plt
== htab
->elf
.splt
)
4302 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
4303 got_offset
= (plt_index
+ 3) * 4;
4307 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
4308 got_offset
= plt_index
* 4;
4311 /* Fill in the entry in the procedure linkage table. */
4314 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
4316 bfd_put_32 (output_bfd
,
4317 (gotplt
->output_section
->vma
4318 + gotplt
->output_offset
4320 plt
->contents
+ h
->plt
.offset
+ 2);
4322 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
)
4324 int s
, k
, reloc_index
;
4326 /* Create the R_386_32 relocation referencing the GOT
4327 for this PLT entry. */
4329 /* S: Current slot number (zero-based). */
4330 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
4331 /* K: Number of relocations for PLTResolve. */
4333 k
= PLTRESOLVE_RELOCS_SHLIB
;
4335 k
= PLTRESOLVE_RELOCS
;
4336 /* Skip the PLTresolve relocations, and the relocations for
4337 the other PLT slots. */
4338 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
4339 loc
= (htab
->srelplt2
->contents
+ reloc_index
4340 * sizeof (Elf32_External_Rel
));
4342 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
4343 + htab
->elf
.splt
->output_offset
4344 + h
->plt
.offset
+ 2),
4345 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4346 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4348 /* Create the R_386_32 relocation referencing the beginning of
4349 the PLT for this GOT entry. */
4350 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4351 + htab
->elf
.sgotplt
->output_offset
4353 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4354 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4355 loc
+ sizeof (Elf32_External_Rel
));
4360 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
4362 bfd_put_32 (output_bfd
, got_offset
,
4363 plt
->contents
+ h
->plt
.offset
+ 2);
4366 /* Don't fill PLT entry for static executables. */
4367 if (plt
== htab
->elf
.splt
)
4369 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
4370 plt
->contents
+ h
->plt
.offset
+ 7);
4371 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
4372 plt
->contents
+ h
->plt
.offset
+ 12);
4375 /* Fill in the entry in the global offset table. */
4376 bfd_put_32 (output_bfd
,
4377 (plt
->output_section
->vma
4378 + plt
->output_offset
4381 gotplt
->contents
+ got_offset
);
4383 /* Fill in the entry in the .rel.plt section. */
4384 rel
.r_offset
= (gotplt
->output_section
->vma
4385 + gotplt
->output_offset
4387 if (h
->dynindx
== -1
4388 || ((info
->executable
4389 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4391 && h
->type
== STT_GNU_IFUNC
))
4393 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4394 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4395 in the .got.plt section. */
4396 bfd_put_32 (output_bfd
,
4397 (h
->root
.u
.def
.value
4398 + h
->root
.u
.def
.section
->output_section
->vma
4399 + h
->root
.u
.def
.section
->output_offset
),
4400 gotplt
->contents
+ got_offset
);
4401 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4404 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
4405 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
4406 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4408 if (!h
->def_regular
)
4410 /* Mark the symbol as undefined, rather than as defined in
4411 the .plt section. Leave the value if there were any
4412 relocations where pointer equality matters (this is a clue
4413 for the dynamic linker, to make function pointer
4414 comparisons work between an application and shared
4415 library), otherwise set it to zero. If a function is only
4416 called from a binary, there is no need to slow down
4417 shared libraries because of that. */
4418 sym
->st_shndx
= SHN_UNDEF
;
4419 if (!h
->pointer_equality_needed
)
4424 if (h
->got
.offset
!= (bfd_vma
) -1
4425 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
4426 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
4428 Elf_Internal_Rela rel
;
4431 /* This symbol has an entry in the global offset table. Set it
4434 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4437 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4438 + htab
->elf
.sgot
->output_offset
4439 + (h
->got
.offset
& ~(bfd_vma
) 1));
4441 /* If this is a static link, or it is a -Bsymbolic link and the
4442 symbol is defined locally or was forced to be local because
4443 of a version file, we just want to emit a RELATIVE reloc.
4444 The entry in the global offset table will already have been
4445 initialized in the relocate_section function. */
4447 && h
->type
== STT_GNU_IFUNC
)
4451 /* Generate R_386_GLOB_DAT. */
4458 if (!h
->pointer_equality_needed
)
4461 /* For non-shared object, we can't use .got.plt, which
4462 contains the real function addres if we need pointer
4463 equality. We load the GOT entry with the PLT entry. */
4464 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4465 bfd_put_32 (output_bfd
,
4466 (plt
->output_section
->vma
4467 + plt
->output_offset
+ h
->plt
.offset
),
4468 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4472 else if (info
->shared
4473 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4475 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4476 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4480 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4482 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4483 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4484 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
4487 loc
= htab
->elf
.srelgot
->contents
;
4488 loc
+= htab
->elf
.srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4489 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4494 Elf_Internal_Rela rel
;
4497 /* This symbol needs a copy reloc. Set it up. */
4499 if (h
->dynindx
== -1
4500 || (h
->root
.type
!= bfd_link_hash_defined
4501 && h
->root
.type
!= bfd_link_hash_defweak
)
4502 || htab
->srelbss
== NULL
)
4505 rel
.r_offset
= (h
->root
.u
.def
.value
4506 + h
->root
.u
.def
.section
->output_section
->vma
4507 + h
->root
.u
.def
.section
->output_offset
);
4508 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
4509 loc
= htab
->srelbss
->contents
;
4510 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4511 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4514 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4515 be NULL for local symbols.
4517 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
4518 is relative to the ".got" section. */
4520 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4521 || (!get_elf_i386_backend_data (output_bfd
)->is_vxworks
4522 && h
== htab
->elf
.hgot
)))
4523 sym
->st_shndx
= SHN_ABS
;
4528 /* Finish up local dynamic symbol handling. We set the contents of
4529 various dynamic sections here. */
4532 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
4534 struct elf_link_hash_entry
*h
4535 = (struct elf_link_hash_entry
*) *slot
;
4536 struct bfd_link_info
*info
4537 = (struct bfd_link_info
*) inf
;
4539 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
4543 /* Used to decide how to sort relocs in an optimal manner for the
4544 dynamic linker, before writing them out. */
4546 static enum elf_reloc_type_class
4547 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
4549 switch (ELF32_R_TYPE (rela
->r_info
))
4551 case R_386_RELATIVE
:
4552 return reloc_class_relative
;
4553 case R_386_JUMP_SLOT
:
4554 return reloc_class_plt
;
4556 return reloc_class_copy
;
4558 return reloc_class_normal
;
4562 /* Finish up the dynamic sections. */
4565 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
4566 struct bfd_link_info
*info
)
4568 struct elf_i386_link_hash_table
*htab
;
4572 htab
= elf_i386_hash_table (info
);
4576 dynobj
= htab
->elf
.dynobj
;
4577 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4579 if (htab
->elf
.dynamic_sections_created
)
4581 Elf32_External_Dyn
*dyncon
, *dynconend
;
4583 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4586 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4587 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4588 for (; dyncon
< dynconend
; dyncon
++)
4590 Elf_Internal_Dyn dyn
;
4593 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4598 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
4599 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
4604 s
= htab
->elf
.sgotplt
;
4605 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4609 s
= htab
->elf
.srelplt
;
4610 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4614 s
= htab
->elf
.srelplt
;
4615 dyn
.d_un
.d_val
= s
->size
;
4619 /* My reading of the SVR4 ABI indicates that the
4620 procedure linkage table relocs (DT_JMPREL) should be
4621 included in the overall relocs (DT_REL). This is
4622 what Solaris does. However, UnixWare can not handle
4623 that case. Therefore, we override the DT_RELSZ entry
4624 here to make it not include the JMPREL relocs. */
4625 s
= htab
->elf
.srelplt
;
4628 dyn
.d_un
.d_val
-= s
->size
;
4632 /* We may not be using the standard ELF linker script.
4633 If .rel.plt is the first .rel section, we adjust
4634 DT_REL to not include it. */
4635 s
= htab
->elf
.srelplt
;
4638 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
4640 dyn
.d_un
.d_ptr
+= s
->size
;
4644 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4647 /* Fill in the first entry in the procedure linkage table. */
4648 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4652 memcpy (htab
->elf
.splt
->contents
, elf_i386_pic_plt0_entry
,
4653 sizeof (elf_i386_pic_plt0_entry
));
4654 memset (htab
->elf
.splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
4655 get_elf_i386_backend_data (output_bfd
)->plt0_pad_byte
,
4656 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
4660 memcpy (htab
->elf
.splt
->contents
, elf_i386_plt0_entry
,
4661 sizeof(elf_i386_plt0_entry
));
4662 memset (htab
->elf
.splt
->contents
+ sizeof (elf_i386_plt0_entry
),
4663 get_elf_i386_backend_data (output_bfd
)->plt0_pad_byte
,
4664 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
4665 bfd_put_32 (output_bfd
,
4666 (htab
->elf
.sgotplt
->output_section
->vma
4667 + htab
->elf
.sgotplt
->output_offset
4669 htab
->elf
.splt
->contents
+ 2);
4670 bfd_put_32 (output_bfd
,
4671 (htab
->elf
.sgotplt
->output_section
->vma
4672 + htab
->elf
.sgotplt
->output_offset
4674 htab
->elf
.splt
->contents
+ 8);
4676 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
)
4678 Elf_Internal_Rela rel
;
4680 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4681 On IA32 we use REL relocations so the addend goes in
4682 the PLT directly. */
4683 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
4684 + htab
->elf
.splt
->output_offset
4686 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4687 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4688 htab
->srelplt2
->contents
);
4689 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
4690 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
4691 + htab
->elf
.splt
->output_offset
4693 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4694 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4695 htab
->srelplt2
->contents
+
4696 sizeof (Elf32_External_Rel
));
4700 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4701 really seem like the right value. */
4702 elf_section_data (htab
->elf
.splt
->output_section
)
4703 ->this_hdr
.sh_entsize
= 4;
4705 /* Correct the .rel.plt.unloaded relocations. */
4706 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
4709 int num_plts
= (htab
->elf
.splt
->size
/ PLT_ENTRY_SIZE
) - 1;
4712 p
= htab
->srelplt2
->contents
;
4714 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
4716 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
4718 for (; num_plts
; num_plts
--)
4720 Elf_Internal_Rela rel
;
4721 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4722 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4723 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4724 p
+= sizeof (Elf32_External_Rel
);
4726 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4727 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4728 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4729 p
+= sizeof (Elf32_External_Rel
);
4735 if (htab
->elf
.sgotplt
)
4737 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4739 (*_bfd_error_handler
)
4740 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4744 /* Fill in the first three entries in the global offset table. */
4745 if (htab
->elf
.sgotplt
->size
> 0)
4747 bfd_put_32 (output_bfd
,
4749 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
4750 htab
->elf
.sgotplt
->contents
);
4751 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
4752 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
4755 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
4758 /* Adjust .eh_frame for .plt section. */
4759 if (htab
->plt_eh_frame
!= NULL
)
4761 if (htab
->elf
.splt
!= NULL
4762 && htab
->elf
.splt
->size
!= 0
4763 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
4764 && htab
->elf
.splt
->output_section
!= NULL
4765 && htab
->plt_eh_frame
->output_section
!= NULL
)
4767 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
4768 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
4769 + htab
->plt_eh_frame
->output_offset
4770 + PLT_FDE_START_OFFSET
;
4771 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
4772 htab
->plt_eh_frame
->contents
4773 + PLT_FDE_START_OFFSET
);
4775 if (htab
->plt_eh_frame
->sec_info_type
4776 == ELF_INFO_TYPE_EH_FRAME
)
4778 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
4780 htab
->plt_eh_frame
->contents
))
4785 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4786 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4788 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4789 htab_traverse (htab
->loc_hash_table
,
4790 elf_i386_finish_local_dynamic_symbol
,
4796 /* Return address for Ith PLT stub in section PLT, for relocation REL
4797 or (bfd_vma) -1 if it should not be included. */
4800 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
4801 const arelent
*rel ATTRIBUTE_UNUSED
)
4803 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4806 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4809 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
4811 if (h
->plt
.offset
!= (bfd_vma
) -1
4813 && !h
->pointer_equality_needed
)
4816 return _bfd_elf_hash_symbol (h
);
4819 /* Hook called by the linker routine which adds symbols from an object
4823 elf_i386_add_symbol_hook (bfd
* abfd
,
4824 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4825 Elf_Internal_Sym
* sym
,
4826 const char ** namep ATTRIBUTE_UNUSED
,
4827 flagword
* flagsp ATTRIBUTE_UNUSED
,
4828 asection
** secp ATTRIBUTE_UNUSED
,
4829 bfd_vma
* valp ATTRIBUTE_UNUSED
)
4831 if ((abfd
->flags
& DYNAMIC
) == 0
4832 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
4833 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
4834 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
4839 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4840 #define TARGET_LITTLE_NAME "elf32-i386"
4841 #define ELF_ARCH bfd_arch_i386
4842 #define ELF_TARGET_ID I386_ELF_DATA
4843 #define ELF_MACHINE_CODE EM_386
4844 #define ELF_MAXPAGESIZE 0x1000
4846 #define elf_backend_can_gc_sections 1
4847 #define elf_backend_can_refcount 1
4848 #define elf_backend_want_got_plt 1
4849 #define elf_backend_plt_readonly 1
4850 #define elf_backend_want_plt_sym 0
4851 #define elf_backend_got_header_size 12
4852 #define elf_backend_plt_alignment 4
4854 /* Support RELA for objdump of prelink objects. */
4855 #define elf_info_to_howto elf_i386_info_to_howto_rel
4856 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4858 #define bfd_elf32_mkobject elf_i386_mkobject
4860 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4861 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
4862 #define bfd_elf32_bfd_link_hash_table_free elf_i386_link_hash_table_free
4863 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
4864 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
4866 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
4867 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4868 #define elf_backend_check_relocs elf_i386_check_relocs
4869 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
4870 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
4871 #define elf_backend_fake_sections elf_i386_fake_sections
4872 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4873 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4874 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4875 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
4876 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
4877 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
4878 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
4879 #define elf_backend_relocate_section elf_i386_relocate_section
4880 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
4881 #define elf_backend_always_size_sections elf_i386_always_size_sections
4882 #define elf_backend_omit_section_dynsym \
4883 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4884 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
4885 #define elf_backend_hash_symbol elf_i386_hash_symbol
4886 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
4887 #undef elf_backend_post_process_headers
4888 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4890 #include "elf32-target.h"
4892 /* FreeBSD support. */
4894 #undef TARGET_LITTLE_SYM
4895 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4896 #undef TARGET_LITTLE_NAME
4897 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
4899 #define ELF_OSABI ELFOSABI_FREEBSD
4901 /* The kernel recognizes executables as valid only if they carry a
4902 "FreeBSD" label in the ELF header. So we put this label on all
4903 executables and (for simplicity) also all other object files. */
4906 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
4908 _bfd_elf_set_osabi (abfd
, info
);
4910 #ifdef OLD_FREEBSD_ABI_LABEL
4911 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4912 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
4916 #undef elf_backend_post_process_headers
4917 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
4919 #define elf32_bed elf32_i386_fbsd_bed
4921 #undef elf_backend_add_symbol_hook
4923 #include "elf32-target.h"
4927 #undef TARGET_LITTLE_SYM
4928 #define TARGET_LITTLE_SYM bfd_elf32_i386_sol2_vec
4929 #undef TARGET_LITTLE_NAME
4930 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
4932 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4933 objects won't be recognized. */
4937 #define elf32_bed elf32_i386_sol2_bed
4939 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
4941 #undef elf_backend_static_tls_alignment
4942 #define elf_backend_static_tls_alignment 8
4944 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4946 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4948 #undef elf_backend_want_plt_sym
4949 #define elf_backend_want_plt_sym 1
4951 #include "elf32-target.h"
4953 /* VxWorks support. */
4955 #undef TARGET_LITTLE_SYM
4956 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4957 #undef TARGET_LITTLE_NAME
4958 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
4961 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
4963 0x90, /* plt0_pad_byte */
4967 #undef elf_backend_arch_data
4968 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
4970 #undef elf_backend_relocs_compatible
4971 #undef elf_backend_post_process_headers
4972 #undef elf_backend_add_symbol_hook
4973 #define elf_backend_add_symbol_hook \
4974 elf_vxworks_add_symbol_hook
4975 #undef elf_backend_link_output_symbol_hook
4976 #define elf_backend_link_output_symbol_hook \
4977 elf_vxworks_link_output_symbol_hook
4978 #undef elf_backend_emit_relocs
4979 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4980 #undef elf_backend_final_write_processing
4981 #define elf_backend_final_write_processing \
4982 elf_vxworks_final_write_processing
4983 #undef elf_backend_static_tls_alignment
4985 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4987 #undef elf_backend_want_plt_sym
4988 #define elf_backend_want_plt_sym 1
4991 #define elf32_bed elf32_i386_vxworks_bed
4993 #include "elf32-target.h"