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 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
30 /* 386 uses REL relocations instead of RELA. */
35 static reloc_howto_type elf_howto_table
[]=
37 HOWTO(R_386_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_bitfield
,
38 bfd_elf_generic_reloc
, "R_386_NONE",
39 TRUE
, 0x00000000, 0x00000000, FALSE
),
40 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
41 bfd_elf_generic_reloc
, "R_386_32",
42 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
43 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
44 bfd_elf_generic_reloc
, "R_386_PC32",
45 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
46 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
47 bfd_elf_generic_reloc
, "R_386_GOT32",
48 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
49 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
50 bfd_elf_generic_reloc
, "R_386_PLT32",
51 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
52 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
53 bfd_elf_generic_reloc
, "R_386_COPY",
54 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
55 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
56 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
57 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
58 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
59 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
60 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
61 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_386_RELATIVE",
63 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
64 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
65 bfd_elf_generic_reloc
, "R_386_GOTOFF",
66 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
67 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
68 bfd_elf_generic_reloc
, "R_386_GOTPC",
69 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
71 /* We have a gap in the reloc numbers here.
72 R_386_standard counts the number up to this point, and
73 R_386_ext_offset is the value to subtract from a reloc type of
74 R_386_16 thru R_386_PC8 to form an index into this table. */
75 #define R_386_standard (R_386_GOTPC + 1)
76 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
78 /* These relocs are a GNU extension. */
79 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
81 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
82 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_386_TLS_IE",
84 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
85 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
87 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
88 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_386_TLS_LE",
90 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
91 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_386_TLS_GD",
93 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
94 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
96 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
97 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_386_16",
99 TRUE
, 0xffff, 0xffff, FALSE
),
100 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
101 bfd_elf_generic_reloc
, "R_386_PC16",
102 TRUE
, 0xffff, 0xffff, TRUE
),
103 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
104 bfd_elf_generic_reloc
, "R_386_8",
105 TRUE
, 0xff, 0xff, FALSE
),
106 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
107 bfd_elf_generic_reloc
, "R_386_PC8",
108 TRUE
, 0xff, 0xff, TRUE
),
110 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
111 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
112 /* These are common with Solaris TLS implementation. */
113 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
114 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
115 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
116 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
117 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
118 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
119 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
120 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
121 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
122 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
123 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
124 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
125 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
126 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
127 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
128 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
129 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
130 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
132 HOWTO(R_386_TLS_GOTDESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
133 bfd_elf_generic_reloc
, "R_386_TLS_GOTDESC",
134 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
135 HOWTO(R_386_TLS_DESC_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
136 bfd_elf_generic_reloc
, "R_386_TLS_DESC_CALL",
138 HOWTO(R_386_TLS_DESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
139 bfd_elf_generic_reloc
, "R_386_TLS_DESC",
140 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
141 HOWTO(R_386_IRELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
142 bfd_elf_generic_reloc
, "R_386_IRELATIVE",
143 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
146 #define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
147 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
149 /* GNU extension to record C++ vtable hierarchy. */
150 HOWTO (R_386_GNU_VTINHERIT
, /* type */
152 2, /* size (0 = byte, 1 = short, 2 = long) */
154 FALSE
, /* pc_relative */
156 complain_overflow_dont
, /* complain_on_overflow */
157 NULL
, /* special_function */
158 "R_386_GNU_VTINHERIT", /* name */
159 FALSE
, /* partial_inplace */
162 FALSE
), /* pcrel_offset */
164 /* GNU extension to record C++ vtable member usage. */
165 HOWTO (R_386_GNU_VTENTRY
, /* type */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
169 FALSE
, /* pc_relative */
171 complain_overflow_dont
, /* complain_on_overflow */
172 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
173 "R_386_GNU_VTENTRY", /* name */
174 FALSE
, /* partial_inplace */
177 FALSE
) /* pcrel_offset */
179 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
183 #ifdef DEBUG_GEN_RELOC
185 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
190 static reloc_howto_type
*
191 elf_i386_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
192 bfd_reloc_code_real_type code
)
197 TRACE ("BFD_RELOC_NONE");
198 return &elf_howto_table
[R_386_NONE
];
201 TRACE ("BFD_RELOC_32");
202 return &elf_howto_table
[R_386_32
];
205 TRACE ("BFD_RELOC_CTOR");
206 return &elf_howto_table
[R_386_32
];
208 case BFD_RELOC_32_PCREL
:
209 TRACE ("BFD_RELOC_PC32");
210 return &elf_howto_table
[R_386_PC32
];
212 case BFD_RELOC_386_GOT32
:
213 TRACE ("BFD_RELOC_386_GOT32");
214 return &elf_howto_table
[R_386_GOT32
];
216 case BFD_RELOC_386_PLT32
:
217 TRACE ("BFD_RELOC_386_PLT32");
218 return &elf_howto_table
[R_386_PLT32
];
220 case BFD_RELOC_386_COPY
:
221 TRACE ("BFD_RELOC_386_COPY");
222 return &elf_howto_table
[R_386_COPY
];
224 case BFD_RELOC_386_GLOB_DAT
:
225 TRACE ("BFD_RELOC_386_GLOB_DAT");
226 return &elf_howto_table
[R_386_GLOB_DAT
];
228 case BFD_RELOC_386_JUMP_SLOT
:
229 TRACE ("BFD_RELOC_386_JUMP_SLOT");
230 return &elf_howto_table
[R_386_JUMP_SLOT
];
232 case BFD_RELOC_386_RELATIVE
:
233 TRACE ("BFD_RELOC_386_RELATIVE");
234 return &elf_howto_table
[R_386_RELATIVE
];
236 case BFD_RELOC_386_GOTOFF
:
237 TRACE ("BFD_RELOC_386_GOTOFF");
238 return &elf_howto_table
[R_386_GOTOFF
];
240 case BFD_RELOC_386_GOTPC
:
241 TRACE ("BFD_RELOC_386_GOTPC");
242 return &elf_howto_table
[R_386_GOTPC
];
244 /* These relocs are a GNU extension. */
245 case BFD_RELOC_386_TLS_TPOFF
:
246 TRACE ("BFD_RELOC_386_TLS_TPOFF");
247 return &elf_howto_table
[R_386_TLS_TPOFF
- R_386_ext_offset
];
249 case BFD_RELOC_386_TLS_IE
:
250 TRACE ("BFD_RELOC_386_TLS_IE");
251 return &elf_howto_table
[R_386_TLS_IE
- R_386_ext_offset
];
253 case BFD_RELOC_386_TLS_GOTIE
:
254 TRACE ("BFD_RELOC_386_TLS_GOTIE");
255 return &elf_howto_table
[R_386_TLS_GOTIE
- R_386_ext_offset
];
257 case BFD_RELOC_386_TLS_LE
:
258 TRACE ("BFD_RELOC_386_TLS_LE");
259 return &elf_howto_table
[R_386_TLS_LE
- R_386_ext_offset
];
261 case BFD_RELOC_386_TLS_GD
:
262 TRACE ("BFD_RELOC_386_TLS_GD");
263 return &elf_howto_table
[R_386_TLS_GD
- R_386_ext_offset
];
265 case BFD_RELOC_386_TLS_LDM
:
266 TRACE ("BFD_RELOC_386_TLS_LDM");
267 return &elf_howto_table
[R_386_TLS_LDM
- R_386_ext_offset
];
270 TRACE ("BFD_RELOC_16");
271 return &elf_howto_table
[R_386_16
- R_386_ext_offset
];
273 case BFD_RELOC_16_PCREL
:
274 TRACE ("BFD_RELOC_16_PCREL");
275 return &elf_howto_table
[R_386_PC16
- R_386_ext_offset
];
278 TRACE ("BFD_RELOC_8");
279 return &elf_howto_table
[R_386_8
- R_386_ext_offset
];
281 case BFD_RELOC_8_PCREL
:
282 TRACE ("BFD_RELOC_8_PCREL");
283 return &elf_howto_table
[R_386_PC8
- R_386_ext_offset
];
285 /* Common with Sun TLS implementation. */
286 case BFD_RELOC_386_TLS_LDO_32
:
287 TRACE ("BFD_RELOC_386_TLS_LDO_32");
288 return &elf_howto_table
[R_386_TLS_LDO_32
- R_386_tls_offset
];
290 case BFD_RELOC_386_TLS_IE_32
:
291 TRACE ("BFD_RELOC_386_TLS_IE_32");
292 return &elf_howto_table
[R_386_TLS_IE_32
- R_386_tls_offset
];
294 case BFD_RELOC_386_TLS_LE_32
:
295 TRACE ("BFD_RELOC_386_TLS_LE_32");
296 return &elf_howto_table
[R_386_TLS_LE_32
- R_386_tls_offset
];
298 case BFD_RELOC_386_TLS_DTPMOD32
:
299 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
300 return &elf_howto_table
[R_386_TLS_DTPMOD32
- R_386_tls_offset
];
302 case BFD_RELOC_386_TLS_DTPOFF32
:
303 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
304 return &elf_howto_table
[R_386_TLS_DTPOFF32
- R_386_tls_offset
];
306 case BFD_RELOC_386_TLS_TPOFF32
:
307 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
308 return &elf_howto_table
[R_386_TLS_TPOFF32
- R_386_tls_offset
];
310 case BFD_RELOC_386_TLS_GOTDESC
:
311 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
312 return &elf_howto_table
[R_386_TLS_GOTDESC
- R_386_tls_offset
];
314 case BFD_RELOC_386_TLS_DESC_CALL
:
315 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
316 return &elf_howto_table
[R_386_TLS_DESC_CALL
- R_386_tls_offset
];
318 case BFD_RELOC_386_TLS_DESC
:
319 TRACE ("BFD_RELOC_386_TLS_DESC");
320 return &elf_howto_table
[R_386_TLS_DESC
- R_386_tls_offset
];
322 case BFD_RELOC_386_IRELATIVE
:
323 TRACE ("BFD_RELOC_386_IRELATIVE");
324 return &elf_howto_table
[R_386_IRELATIVE
];
326 case BFD_RELOC_VTABLE_INHERIT
:
327 TRACE ("BFD_RELOC_VTABLE_INHERIT");
328 return &elf_howto_table
[R_386_GNU_VTINHERIT
- R_386_vt_offset
];
330 case BFD_RELOC_VTABLE_ENTRY
:
331 TRACE ("BFD_RELOC_VTABLE_ENTRY");
332 return &elf_howto_table
[R_386_GNU_VTENTRY
- R_386_vt_offset
];
342 static reloc_howto_type
*
343 elf_i386_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
348 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
349 if (elf_howto_table
[i
].name
!= NULL
350 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
351 return &elf_howto_table
[i
];
356 static reloc_howto_type
*
357 elf_i386_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
361 if ((indx
= r_type
) >= R_386_standard
362 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
363 >= R_386_ext
- R_386_standard
)
364 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
365 >= R_386_irelative
- R_386_ext
)
366 && ((indx
= r_type
- R_386_vt_offset
) - R_386_irelative
367 >= R_386_vt
- R_386_irelative
))
369 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
373 BFD_ASSERT (elf_howto_table
[indx
].type
== r_type
);
374 return &elf_howto_table
[indx
];
378 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
380 Elf_Internal_Rela
*dst
)
382 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
383 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
386 /* Return whether a symbol name implies a local label. The UnixWare
387 2.1 cc generates temporary symbols that start with .X, so we
388 recognize them here. FIXME: do other SVR4 compilers also use .X?.
389 If so, we should move the .X recognition into
390 _bfd_elf_is_local_label_name. */
393 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
395 if (name
[0] == '.' && name
[1] == 'X')
398 return _bfd_elf_is_local_label_name (abfd
, name
);
401 /* Support for core dump NOTE sections. */
404 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
409 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
411 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
417 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
420 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
424 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
428 switch (note
->descsz
)
433 case 144: /* Linux/i386 */
435 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
438 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
448 /* Make a ".reg/999" section. */
449 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
450 size
, note
->descpos
+ offset
);
454 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
456 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
458 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
463 elf_tdata (abfd
)->core_program
464 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
465 elf_tdata (abfd
)->core_command
466 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
470 switch (note
->descsz
)
475 case 124: /* Linux/i386 elf_prpsinfo. */
476 elf_tdata (abfd
)->core_program
477 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
478 elf_tdata (abfd
)->core_command
479 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
483 /* Note that for some reason, a spurious space is tacked
484 onto the end of the args in some (at least one anyway)
485 implementations, so strip it off if it exists. */
487 char *command
= elf_tdata (abfd
)->core_command
;
488 int n
= strlen (command
);
490 if (0 < n
&& command
[n
- 1] == ' ')
491 command
[n
- 1] = '\0';
497 /* Functions for the i386 ELF linker.
499 In order to gain some understanding of code in this file without
500 knowing all the intricate details of the linker, note the
503 Functions named elf_i386_* are called by external routines, other
504 functions are only called locally. elf_i386_* functions appear
505 in this file more or less in the order in which they are called
506 from external routines. eg. elf_i386_check_relocs is called
507 early in the link process, elf_i386_finish_dynamic_sections is
508 one of the last functions. */
511 /* The name of the dynamic interpreter. This is put in the .interp
514 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
516 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
517 copying dynamic variables from a shared lib into an app's dynbss
518 section, and instead use a dynamic relocation to point into the
520 #define ELIMINATE_COPY_RELOCS 1
522 /* The size in bytes of an entry in the procedure linkage table. */
524 #define PLT_ENTRY_SIZE 16
526 /* The first entry in an absolute procedure linkage table looks like
527 this. See the SVR4 ABI i386 supplement to see how this works.
528 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
530 static const bfd_byte elf_i386_plt0_entry
[12] =
532 0xff, 0x35, /* pushl contents of address */
533 0, 0, 0, 0, /* replaced with address of .got + 4. */
534 0xff, 0x25, /* jmp indirect */
535 0, 0, 0, 0 /* replaced with address of .got + 8. */
538 /* Subsequent entries in an absolute procedure linkage table look like
541 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
543 0xff, 0x25, /* jmp indirect */
544 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
545 0x68, /* pushl immediate */
546 0, 0, 0, 0, /* replaced with offset into relocation table. */
547 0xe9, /* jmp relative */
548 0, 0, 0, 0 /* replaced with offset to start of .plt. */
551 /* The first entry in a PIC procedure linkage table look like this.
552 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
554 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
556 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
557 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
560 /* Subsequent entries in a PIC procedure linkage table look like this. */
562 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0xa3, /* jmp *offset(%ebx) */
565 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
573 for the PLTResolve stub and then for each PLT entry. */
574 #define PLTRESOLVE_RELOCS_SHLIB 0
575 #define PLTRESOLVE_RELOCS 2
576 #define PLT_NON_JUMP_SLOT_RELOCS 2
578 /* The i386 linker needs to keep track of the number of relocs that it
579 decides to copy as dynamic relocs in check_relocs for each symbol.
580 This is so that it can later discard them if they are found to be
581 unnecessary. We store the information in a field extending the
582 regular ELF linker hash table. */
584 struct elf_i386_dyn_relocs
586 struct elf_i386_dyn_relocs
*next
;
588 /* The input section of the reloc. */
591 /* Total number of relocs copied for the input section. */
594 /* Number of pc-relative relocs copied for the input section. */
595 bfd_size_type pc_count
;
598 /* i386 ELF linker hash entry. */
600 struct elf_i386_link_hash_entry
602 struct elf_link_hash_entry elf
;
604 /* Track dynamic relocs copied for this symbol. */
605 struct elf_i386_dyn_relocs
*dyn_relocs
;
607 #define GOT_UNKNOWN 0
611 #define GOT_TLS_IE_POS 5
612 #define GOT_TLS_IE_NEG 6
613 #define GOT_TLS_IE_BOTH 7
614 #define GOT_TLS_GDESC 8
615 #define GOT_TLS_GD_BOTH_P(type) \
616 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
617 #define GOT_TLS_GD_P(type) \
618 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
619 #define GOT_TLS_GDESC_P(type) \
620 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
621 #define GOT_TLS_GD_ANY_P(type) \
622 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
623 unsigned char tls_type
;
625 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
626 starting at the end of the jump table. */
630 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
632 struct elf_i386_obj_tdata
634 struct elf_obj_tdata root
;
636 /* tls_type for each local got entry. */
637 char *local_got_tls_type
;
639 /* GOTPLT entries for TLS descriptors. */
640 bfd_vma
*local_tlsdesc_gotent
;
643 #define elf_i386_tdata(abfd) \
644 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
646 #define elf_i386_local_got_tls_type(abfd) \
647 (elf_i386_tdata (abfd)->local_got_tls_type)
649 #define elf_i386_local_tlsdesc_gotent(abfd) \
650 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
652 #define is_i386_elf(bfd) \
653 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
654 && elf_tdata (bfd) != NULL \
655 && elf_object_id (bfd) == I386_ELF_TDATA)
658 elf_i386_mkobject (bfd
*abfd
)
660 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
664 /* i386 ELF linker hash table. */
666 struct elf_i386_link_hash_table
668 struct elf_link_hash_table elf
;
670 /* Short-cuts to get to dynamic linker sections. */
682 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
685 /* True if the target system is VxWorks. */
688 /* Value used to fill the last word of the first plt entry. */
689 bfd_byte plt0_pad_byte
;
691 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
692 bfd_vma next_tls_desc_index
;
695 bfd_signed_vma refcount
;
699 /* The amount of space used by the reserved portion of the sgotplt
700 section, plus whatever space is used by the jump slots. */
701 bfd_vma sgotplt_jump_table_size
;
703 /* Small local sym to section mapping cache. */
704 struct sym_sec_cache sym_sec
;
706 /* _TLS_MODULE_BASE_ symbol. */
707 struct bfd_link_hash_entry
*tls_module_base
;
710 /* Get the i386 ELF linker hash table from a link_info structure. */
712 #define elf_i386_hash_table(p) \
713 ((struct elf_i386_link_hash_table *) ((p)->hash))
715 #define elf_i386_compute_jump_table_size(htab) \
716 ((htab)->next_tls_desc_index * 4)
718 /* Create an entry in an i386 ELF linker hash table. */
720 static struct bfd_hash_entry
*
721 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
722 struct bfd_hash_table
*table
,
725 /* Allocate the structure if it has not already been allocated by a
729 entry
= bfd_hash_allocate (table
,
730 sizeof (struct elf_i386_link_hash_entry
));
735 /* Call the allocation method of the superclass. */
736 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
739 struct elf_i386_link_hash_entry
*eh
;
741 eh
= (struct elf_i386_link_hash_entry
*) entry
;
742 eh
->dyn_relocs
= NULL
;
743 eh
->tls_type
= GOT_UNKNOWN
;
744 eh
->tlsdesc_got
= (bfd_vma
) -1;
750 /* Create an i386 ELF linker hash table. */
752 static struct bfd_link_hash_table
*
753 elf_i386_link_hash_table_create (bfd
*abfd
)
755 struct elf_i386_link_hash_table
*ret
;
756 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
758 ret
= bfd_malloc (amt
);
762 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
763 elf_i386_link_hash_newfunc
,
764 sizeof (struct elf_i386_link_hash_entry
)))
780 ret
->tls_ldm_got
.refcount
= 0;
781 ret
->next_tls_desc_index
= 0;
782 ret
->sgotplt_jump_table_size
= 0;
783 ret
->sym_sec
.abfd
= NULL
;
785 ret
->srelplt2
= NULL
;
786 ret
->plt0_pad_byte
= 0;
787 ret
->tls_module_base
= NULL
;
789 return &ret
->elf
.root
;
792 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
793 shortcuts to them in our hash table. */
796 elf_i386_create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
798 struct elf_i386_link_hash_table
*htab
;
800 if (! _bfd_elf_create_got_section (dynobj
, info
))
803 htab
= elf_i386_hash_table (info
);
804 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
805 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
806 if (!htab
->sgot
|| !htab
->sgotplt
)
809 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rel.got",
810 (SEC_ALLOC
| SEC_LOAD
815 if (htab
->srelgot
== NULL
816 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
821 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
822 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
826 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
828 struct elf_i386_link_hash_table
*htab
;
830 htab
= elf_i386_hash_table (info
);
831 if (!htab
->sgot
&& !elf_i386_create_got_section (dynobj
, info
))
834 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
837 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
838 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
839 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
841 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
843 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
844 || (!info
->shared
&& !htab
->srelbss
))
848 && !elf_vxworks_create_dynamic_sections (dynobj
, info
, &htab
->srelplt2
))
854 /* Copy the extra info we tack onto an elf_link_hash_entry. */
857 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
858 struct elf_link_hash_entry
*dir
,
859 struct elf_link_hash_entry
*ind
)
861 struct elf_i386_link_hash_entry
*edir
, *eind
;
863 edir
= (struct elf_i386_link_hash_entry
*) dir
;
864 eind
= (struct elf_i386_link_hash_entry
*) ind
;
866 if (eind
->dyn_relocs
!= NULL
)
868 if (edir
->dyn_relocs
!= NULL
)
870 struct elf_i386_dyn_relocs
**pp
;
871 struct elf_i386_dyn_relocs
*p
;
873 /* Add reloc counts against the indirect sym to the direct sym
874 list. Merge any entries against the same section. */
875 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
877 struct elf_i386_dyn_relocs
*q
;
879 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
880 if (q
->sec
== p
->sec
)
882 q
->pc_count
+= p
->pc_count
;
883 q
->count
+= p
->count
;
890 *pp
= edir
->dyn_relocs
;
893 edir
->dyn_relocs
= eind
->dyn_relocs
;
894 eind
->dyn_relocs
= NULL
;
897 if (ind
->root
.type
== bfd_link_hash_indirect
898 && dir
->got
.refcount
<= 0)
900 edir
->tls_type
= eind
->tls_type
;
901 eind
->tls_type
= GOT_UNKNOWN
;
904 if (ELIMINATE_COPY_RELOCS
905 && ind
->root
.type
!= bfd_link_hash_indirect
906 && dir
->dynamic_adjusted
)
908 /* If called to transfer flags for a weakdef during processing
909 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
910 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
911 dir
->ref_dynamic
|= ind
->ref_dynamic
;
912 dir
->ref_regular
|= ind
->ref_regular
;
913 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
914 dir
->needs_plt
|= ind
->needs_plt
;
915 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
918 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
928 /* Return TRUE if the TLS access code sequence support transition
932 elf_i386_check_tls_transition (bfd
*abfd
, asection
*sec
,
934 Elf_Internal_Shdr
*symtab_hdr
,
935 struct elf_link_hash_entry
**sym_hashes
,
937 const Elf_Internal_Rela
*rel
,
938 const Elf_Internal_Rela
*relend
)
940 unsigned int val
, type
;
941 unsigned long r_symndx
;
942 struct elf_link_hash_entry
*h
;
945 /* Get the section contents. */
946 if (contents
== NULL
)
948 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
949 contents
= elf_section_data (sec
)->this_hdr
.contents
;
952 /* FIXME: How to better handle error condition? */
953 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
956 /* Cache the section contents for elf_link_input_bfd. */
957 elf_section_data (sec
)->this_hdr
.contents
= contents
;
961 offset
= rel
->r_offset
;
966 if (offset
< 2 || (rel
+ 1) >= relend
)
969 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
970 if (r_type
== R_386_TLS_GD
)
972 /* Check transition from GD access model. Only
973 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
974 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
975 can transit to different access model. */
976 if ((offset
+ 10) > sec
->size
||
977 (type
!= 0x8d && type
!= 0x04))
980 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
983 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
987 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
990 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
995 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
996 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
999 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1005 /* Check transition from LD access model. Only
1006 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1007 can transit to different access model. */
1008 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1011 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1012 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1016 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1019 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1020 if (r_symndx
< symtab_hdr
->sh_info
)
1023 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1024 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1025 may be versioned. */
1027 && h
->root
.root
.string
!= NULL
1028 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1029 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1030 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1034 /* Check transition from IE access model:
1035 movl foo@indntpoff(%rip), %eax
1036 movl foo@indntpoff(%rip), %reg
1037 addl foo@indntpoff(%rip), %reg
1040 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1043 /* Check "movl foo@tpoff(%rip), %eax" first. */
1044 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1051 /* Check movl|addl foo@tpoff(%rip), %reg. */
1052 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1053 return ((type
== 0x8b || type
== 0x03)
1054 && (val
& 0xc7) == 0x05);
1056 case R_386_TLS_GOTIE
:
1057 case R_386_TLS_IE_32
:
1058 /* Check transition from {IE_32,GOTIE} access model:
1059 subl foo@{tpoff,gontoff}(%reg1), %reg2
1060 movl foo@{tpoff,gontoff}(%reg1), %reg2
1061 addl foo@{tpoff,gontoff}(%reg1), %reg2
1064 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1067 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1068 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1071 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1072 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1074 case R_386_TLS_GOTDESC
:
1075 /* Check transition from GDesc access model:
1076 leal x@tlsdesc(%ebx), %eax
1078 Make sure it's a leal adding ebx to a 32-bit offset
1079 into any register, although it's probably almost always
1082 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1085 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1088 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1089 return (val
& 0xc7) == 0x83;
1091 case R_386_TLS_DESC_CALL
:
1092 /* Check transition from GDesc access model:
1093 call *x@tlsdesc(%rax)
1095 if (offset
+ 2 <= sec
->size
)
1097 /* Make sure that it's a call *x@tlsdesc(%rax). */
1098 static i386_opcode16 call
= { { 0xff, 0x10 } };
1099 return bfd_get_16 (abfd
, contents
+ offset
) == call
.i
;
1109 /* Return TRUE if the TLS access transition is OK or no transition
1110 will be performed. Update R_TYPE if there is a transition. */
1113 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1114 asection
*sec
, bfd_byte
*contents
,
1115 Elf_Internal_Shdr
*symtab_hdr
,
1116 struct elf_link_hash_entry
**sym_hashes
,
1117 unsigned int *r_type
, int tls_type
,
1118 const Elf_Internal_Rela
*rel
,
1119 const Elf_Internal_Rela
*relend
,
1120 struct elf_link_hash_entry
*h
)
1122 unsigned int from_type
= *r_type
;
1123 unsigned int to_type
= from_type
;
1124 bfd_boolean check
= TRUE
;
1129 case R_386_TLS_GOTDESC
:
1130 case R_386_TLS_DESC_CALL
:
1131 case R_386_TLS_IE_32
:
1133 case R_386_TLS_GOTIE
:
1137 to_type
= R_386_TLS_LE_32
;
1138 else if (from_type
!= R_386_TLS_IE
1139 && from_type
!= R_386_TLS_GOTIE
)
1140 to_type
= R_386_TLS_IE_32
;
1143 /* When we are called from elf_i386_relocate_section, CONTENTS
1144 isn't NULL and there may be additional transitions based on
1146 if (contents
!= NULL
)
1148 unsigned int new_to_type
= to_type
;
1153 && (tls_type
& GOT_TLS_IE
))
1154 new_to_type
= R_386_TLS_LE_32
;
1156 if (to_type
== R_386_TLS_GD
1157 || to_type
== R_386_TLS_GOTDESC
1158 || to_type
== R_386_TLS_DESC_CALL
)
1160 if (tls_type
== GOT_TLS_IE_POS
)
1161 new_to_type
= R_386_TLS_GOTIE
;
1162 else if (tls_type
& GOT_TLS_IE
)
1163 new_to_type
= R_386_TLS_IE_32
;
1166 /* We checked the transition before when we were called from
1167 elf_i386_check_relocs. We only want to check the new
1168 transition which hasn't been checked before. */
1169 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1170 to_type
= new_to_type
;
1177 to_type
= R_386_TLS_LE_32
;
1184 /* Return TRUE if there is no transition. */
1185 if (from_type
== to_type
)
1188 /* Check if the transition can be performed. */
1190 && ! elf_i386_check_tls_transition (abfd
, sec
, contents
,
1191 symtab_hdr
, sym_hashes
,
1192 from_type
, rel
, relend
))
1194 reloc_howto_type
*from
, *to
;
1196 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1197 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1199 (*_bfd_error_handler
)
1200 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1201 "in section `%A' failed"),
1202 abfd
, sec
, from
->name
, to
->name
,
1203 h
? h
->root
.root
.string
: "a local symbol",
1204 (unsigned long) rel
->r_offset
);
1205 bfd_set_error (bfd_error_bad_value
);
1213 /* Look through the relocs for a section during the first phase, and
1214 calculate needed space in the global offset table, procedure linkage
1215 table, and dynamic reloc sections. */
1218 elf_i386_check_relocs (bfd
*abfd
,
1219 struct bfd_link_info
*info
,
1221 const Elf_Internal_Rela
*relocs
)
1223 struct elf_i386_link_hash_table
*htab
;
1224 Elf_Internal_Shdr
*symtab_hdr
;
1225 struct elf_link_hash_entry
**sym_hashes
;
1226 const Elf_Internal_Rela
*rel
;
1227 const Elf_Internal_Rela
*rel_end
;
1230 if (info
->relocatable
)
1233 BFD_ASSERT (is_i386_elf (abfd
));
1235 htab
= elf_i386_hash_table (info
);
1236 symtab_hdr
= &elf_symtab_hdr (abfd
);
1237 sym_hashes
= elf_sym_hashes (abfd
);
1241 rel_end
= relocs
+ sec
->reloc_count
;
1242 for (rel
= relocs
; rel
< rel_end
; rel
++)
1244 unsigned int r_type
;
1245 unsigned long r_symndx
;
1246 struct elf_link_hash_entry
*h
;
1248 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1249 r_type
= ELF32_R_TYPE (rel
->r_info
);
1251 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1253 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1259 if (r_symndx
< symtab_hdr
->sh_info
)
1263 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1264 while (h
->root
.type
== bfd_link_hash_indirect
1265 || h
->root
.type
== bfd_link_hash_warning
)
1266 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1268 /* Create the ifunc sections for static executables. If we
1269 never see an indirect function symbol nor we are building
1270 a static executable, those sections will be empty and
1271 won't appear in output. */
1282 if (!info
->shared
&& htab
->iplt
== NULL
)
1284 if (!_bfd_elf_create_static_ifunc_sections (abfd
,
1288 htab
->iplt
= bfd_get_section_by_name (abfd
, ".iplt");
1289 htab
->irelplt
= bfd_get_section_by_name (abfd
,
1291 htab
->igotplt
= bfd_get_section_by_name (abfd
,
1301 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1302 it here if it is defined in a non-shared object. */
1303 if (h
->type
== STT_GNU_IFUNC
1306 /* It is referenced by a non-shared object. */
1309 /* STT_GNU_IFUNC symbol must go through PLT. */
1310 h
->plt
.refcount
+= 1;
1312 /* STT_GNU_IFUNC needs dynamic sections. */
1313 if (htab
->elf
.dynobj
== NULL
)
1314 htab
->elf
.dynobj
= abfd
;
1319 (*_bfd_error_handler
)
1320 (_("%B: relocation %s against STT_GNU_IFUNC "
1321 "symbol `%s' isn't handled by %s"), abfd
,
1322 elf_howto_table
[r_type
].name
,
1323 h
->root
.root
.string
, __FUNCTION__
);
1324 bfd_set_error (bfd_error_bad_value
);
1329 h
->pointer_equality_needed
= 1;
1332 struct elf_i386_dyn_relocs
*p
;
1333 struct elf_i386_dyn_relocs
**head
;
1335 /* We must copy these reloc types into the
1336 output file. Create a reloc section in
1337 dynobj and make room for this reloc. */
1340 if (htab
->elf
.dynobj
== NULL
)
1341 htab
->elf
.dynobj
= abfd
;
1343 sreloc
= _bfd_elf_make_dynamic_reloc_section
1344 (sec
, htab
->elf
.dynobj
, 2, abfd
, FALSE
);
1350 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1352 if (p
== NULL
|| p
->sec
!= sec
)
1354 bfd_size_type amt
= sizeof *p
;
1355 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1377 h
->got
.refcount
+= 1;
1378 if (htab
->sgot
== NULL
1379 && !elf_i386_create_got_section (htab
->elf
.dynobj
,
1389 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1390 symtab_hdr
, sym_hashes
,
1391 &r_type
, GOT_UNKNOWN
,
1398 htab
->tls_ldm_got
.refcount
+= 1;
1402 /* This symbol requires a procedure linkage table entry. We
1403 actually build the entry in adjust_dynamic_symbol,
1404 because this might be a case of linking PIC code which is
1405 never referenced by a dynamic object, in which case we
1406 don't need to generate a procedure linkage table entry
1409 /* If this is a local symbol, we resolve it directly without
1410 creating a procedure linkage table entry. */
1415 h
->plt
.refcount
+= 1;
1418 case R_386_TLS_IE_32
:
1420 case R_386_TLS_GOTIE
:
1422 info
->flags
|= DF_STATIC_TLS
;
1427 case R_386_TLS_GOTDESC
:
1428 case R_386_TLS_DESC_CALL
:
1429 /* This symbol requires a global offset table entry. */
1431 int tls_type
, old_tls_type
;
1436 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1437 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1438 case R_386_TLS_GOTDESC
:
1439 case R_386_TLS_DESC_CALL
:
1440 tls_type
= GOT_TLS_GDESC
; break;
1441 case R_386_TLS_IE_32
:
1442 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1443 tls_type
= GOT_TLS_IE_NEG
;
1445 /* If this is a GD->IE transition, we may use either of
1446 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1447 tls_type
= GOT_TLS_IE
;
1450 case R_386_TLS_GOTIE
:
1451 tls_type
= GOT_TLS_IE_POS
; break;
1456 h
->got
.refcount
+= 1;
1457 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1461 bfd_signed_vma
*local_got_refcounts
;
1463 /* This is a global offset table entry for a local symbol. */
1464 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1465 if (local_got_refcounts
== NULL
)
1469 size
= symtab_hdr
->sh_info
;
1470 size
*= (sizeof (bfd_signed_vma
)
1471 + sizeof (bfd_vma
) + sizeof(char));
1472 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1473 if (local_got_refcounts
== NULL
)
1475 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1476 elf_i386_local_tlsdesc_gotent (abfd
)
1477 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1478 elf_i386_local_got_tls_type (abfd
)
1479 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1481 local_got_refcounts
[r_symndx
] += 1;
1482 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1485 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1486 tls_type
|= old_tls_type
;
1487 /* If a TLS symbol is accessed using IE at least once,
1488 there is no point to use dynamic model for it. */
1489 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1490 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1491 || (tls_type
& GOT_TLS_IE
) == 0))
1493 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1494 tls_type
= old_tls_type
;
1495 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1496 && GOT_TLS_GD_ANY_P (tls_type
))
1497 tls_type
|= old_tls_type
;
1500 (*_bfd_error_handler
)
1501 (_("%B: `%s' accessed both as normal and "
1502 "thread local symbol"),
1504 h
? h
->root
.root
.string
: "<local>");
1509 if (old_tls_type
!= tls_type
)
1512 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1514 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1522 if (htab
->sgot
== NULL
)
1524 if (htab
->elf
.dynobj
== NULL
)
1525 htab
->elf
.dynobj
= abfd
;
1526 if (!elf_i386_create_got_section (htab
->elf
.dynobj
, info
))
1529 if (r_type
!= R_386_TLS_IE
)
1533 case R_386_TLS_LE_32
:
1537 info
->flags
|= DF_STATIC_TLS
;
1542 if (h
!= NULL
&& info
->executable
)
1544 /* If this reloc is in a read-only section, we might
1545 need a copy reloc. We can't check reliably at this
1546 stage whether the section is read-only, as input
1547 sections have not yet been mapped to output sections.
1548 Tentatively set the flag for now, and correct in
1549 adjust_dynamic_symbol. */
1552 /* We may need a .plt entry if the function this reloc
1553 refers to is in a shared lib. */
1554 h
->plt
.refcount
+= 1;
1555 if (r_type
!= R_386_PC32
)
1556 h
->pointer_equality_needed
= 1;
1559 /* If we are creating a shared library, and this is a reloc
1560 against a global symbol, or a non PC relative reloc
1561 against a local symbol, then we need to copy the reloc
1562 into the shared library. However, if we are linking with
1563 -Bsymbolic, we do not need to copy a reloc against a
1564 global symbol which is defined in an object we are
1565 including in the link (i.e., DEF_REGULAR is set). At
1566 this point we have not seen all the input files, so it is
1567 possible that DEF_REGULAR is not set now but will be set
1568 later (it is never cleared). In case of a weak definition,
1569 DEF_REGULAR may be cleared later by a strong definition in
1570 a shared library. We account for that possibility below by
1571 storing information in the relocs_copied field of the hash
1572 table entry. A similar situation occurs when creating
1573 shared libraries and symbol visibility changes render the
1576 If on the other hand, we are creating an executable, we
1577 may need to keep relocations for symbols satisfied by a
1578 dynamic library if we manage to avoid copy relocs for the
1581 && (sec
->flags
& SEC_ALLOC
) != 0
1582 && (r_type
!= R_386_PC32
1584 && (! SYMBOLIC_BIND (info
, h
)
1585 || h
->root
.type
== bfd_link_hash_defweak
1586 || !h
->def_regular
))))
1587 || (ELIMINATE_COPY_RELOCS
1589 && (sec
->flags
& SEC_ALLOC
) != 0
1591 && (h
->root
.type
== bfd_link_hash_defweak
1592 || !h
->def_regular
)))
1594 struct elf_i386_dyn_relocs
*p
;
1595 struct elf_i386_dyn_relocs
**head
;
1597 /* We must copy these reloc types into the output file.
1598 Create a reloc section in dynobj and make room for
1602 if (htab
->elf
.dynobj
== NULL
)
1603 htab
->elf
.dynobj
= abfd
;
1605 sreloc
= _bfd_elf_make_dynamic_reloc_section
1606 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1612 /* If this is a global symbol, we count the number of
1613 relocations we need for this symbol. */
1616 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1621 /* Track dynamic relocs needed for local syms too.
1622 We really need local syms available to do this
1626 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1631 vpp
= &elf_section_data (s
)->local_dynrel
;
1632 head
= (struct elf_i386_dyn_relocs
**)vpp
;
1636 if (p
== NULL
|| p
->sec
!= sec
)
1638 bfd_size_type amt
= sizeof *p
;
1639 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1650 if (r_type
== R_386_PC32
)
1655 /* This relocation describes the C++ object vtable hierarchy.
1656 Reconstruct it for later use during GC. */
1657 case R_386_GNU_VTINHERIT
:
1658 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1662 /* This relocation describes which C++ vtable entries are actually
1663 used. Record for later use during GC. */
1664 case R_386_GNU_VTENTRY
:
1665 BFD_ASSERT (h
!= NULL
);
1667 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1679 /* Return the section that should be marked against GC for a given
1683 elf_i386_gc_mark_hook (asection
*sec
,
1684 struct bfd_link_info
*info
,
1685 Elf_Internal_Rela
*rel
,
1686 struct elf_link_hash_entry
*h
,
1687 Elf_Internal_Sym
*sym
)
1690 switch (ELF32_R_TYPE (rel
->r_info
))
1692 case R_386_GNU_VTINHERIT
:
1693 case R_386_GNU_VTENTRY
:
1697 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1700 /* Update the got entry reference counts for the section being removed. */
1703 elf_i386_gc_sweep_hook (bfd
*abfd
,
1704 struct bfd_link_info
*info
,
1706 const Elf_Internal_Rela
*relocs
)
1708 Elf_Internal_Shdr
*symtab_hdr
;
1709 struct elf_link_hash_entry
**sym_hashes
;
1710 bfd_signed_vma
*local_got_refcounts
;
1711 const Elf_Internal_Rela
*rel
, *relend
;
1713 if (info
->relocatable
)
1716 elf_section_data (sec
)->local_dynrel
= NULL
;
1718 symtab_hdr
= &elf_symtab_hdr (abfd
);
1719 sym_hashes
= elf_sym_hashes (abfd
);
1720 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1722 relend
= relocs
+ sec
->reloc_count
;
1723 for (rel
= relocs
; rel
< relend
; rel
++)
1725 unsigned long r_symndx
;
1726 unsigned int r_type
;
1727 struct elf_link_hash_entry
*h
= NULL
;
1729 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1730 if (r_symndx
>= symtab_hdr
->sh_info
)
1732 struct elf_i386_link_hash_entry
*eh
;
1733 struct elf_i386_dyn_relocs
**pp
;
1734 struct elf_i386_dyn_relocs
*p
;
1736 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1737 while (h
->root
.type
== bfd_link_hash_indirect
1738 || h
->root
.type
== bfd_link_hash_warning
)
1739 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1740 eh
= (struct elf_i386_link_hash_entry
*) h
;
1742 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1745 /* Everything must go for SEC. */
1751 r_type
= ELF32_R_TYPE (rel
->r_info
);
1752 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1753 symtab_hdr
, sym_hashes
,
1754 &r_type
, GOT_UNKNOWN
,
1761 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1762 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1766 case R_386_TLS_GOTDESC
:
1767 case R_386_TLS_DESC_CALL
:
1768 case R_386_TLS_IE_32
:
1770 case R_386_TLS_GOTIE
:
1774 if (h
->got
.refcount
> 0)
1775 h
->got
.refcount
-= 1;
1777 else if (local_got_refcounts
!= NULL
)
1779 if (local_got_refcounts
[r_symndx
] > 0)
1780 local_got_refcounts
[r_symndx
] -= 1;
1793 if (h
->plt
.refcount
> 0)
1794 h
->plt
.refcount
-= 1;
1806 /* Adjust a symbol defined by a dynamic object and referenced by a
1807 regular object. The current definition is in some section of the
1808 dynamic object, but we're not including those sections. We have to
1809 change the definition to something the rest of the link can
1813 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1814 struct elf_link_hash_entry
*h
)
1816 struct elf_i386_link_hash_table
*htab
;
1819 /* STT_GNU_IFUNC symbol must go through PLT. */
1820 if (h
->type
== STT_GNU_IFUNC
)
1822 if (h
->plt
.refcount
<= 0)
1824 h
->plt
.offset
= (bfd_vma
) -1;
1830 /* If this is a function, put it in the procedure linkage table. We
1831 will fill in the contents of the procedure linkage table later,
1832 when we know the address of the .got section. */
1833 if (h
->type
== STT_FUNC
1836 if (h
->plt
.refcount
<= 0
1837 || SYMBOL_CALLS_LOCAL (info
, h
)
1838 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1839 && h
->root
.type
== bfd_link_hash_undefweak
))
1841 /* This case can occur if we saw a PLT32 reloc in an input
1842 file, but the symbol was never referred to by a dynamic
1843 object, or if all references were garbage collected. In
1844 such a case, we don't actually need to build a procedure
1845 linkage table, and we can just do a PC32 reloc instead. */
1846 h
->plt
.offset
= (bfd_vma
) -1;
1853 /* It's possible that we incorrectly decided a .plt reloc was
1854 needed for an R_386_PC32 reloc to a non-function sym in
1855 check_relocs. We can't decide accurately between function and
1856 non-function syms in check-relocs; Objects loaded later in
1857 the link may change h->type. So fix it now. */
1858 h
->plt
.offset
= (bfd_vma
) -1;
1860 /* If this is a weak symbol, and there is a real definition, the
1861 processor independent code will have arranged for us to see the
1862 real definition first, and we can just use the same value. */
1863 if (h
->u
.weakdef
!= NULL
)
1865 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1866 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1867 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1868 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1869 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1870 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1874 /* This is a reference to a symbol defined by a dynamic object which
1875 is not a function. */
1877 /* If we are creating a shared library, we must presume that the
1878 only references to the symbol are via the global offset table.
1879 For such cases we need not do anything here; the relocations will
1880 be handled correctly by relocate_section. */
1884 /* If there are no references to this symbol that do not use the
1885 GOT, we don't need to generate a copy reloc. */
1886 if (!h
->non_got_ref
)
1889 /* If -z nocopyreloc was given, we won't generate them either. */
1890 if (info
->nocopyreloc
)
1896 htab
= elf_i386_hash_table (info
);
1898 /* If there aren't any dynamic relocs in read-only sections, then
1899 we can keep the dynamic relocs and avoid the copy reloc. This
1900 doesn't work on VxWorks, where we can not have dynamic relocations
1901 (other than copy and jump slot relocations) in an executable. */
1902 if (ELIMINATE_COPY_RELOCS
&& !htab
->is_vxworks
)
1904 struct elf_i386_link_hash_entry
* eh
;
1905 struct elf_i386_dyn_relocs
*p
;
1907 eh
= (struct elf_i386_link_hash_entry
*) h
;
1908 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1910 s
= p
->sec
->output_section
;
1911 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1924 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1925 h
->root
.root
.string
);
1929 /* We must allocate the symbol in our .dynbss section, which will
1930 become part of the .bss section of the executable. There will be
1931 an entry for this symbol in the .dynsym section. The dynamic
1932 object will contain position independent code, so all references
1933 from the dynamic object to this symbol will go through the global
1934 offset table. The dynamic linker will use the .dynsym entry to
1935 determine the address it must put in the global offset table, so
1936 both the dynamic object and the regular object will refer to the
1937 same memory location for the variable. */
1939 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1940 copy the initial value out of the dynamic object and into the
1941 runtime process image. */
1942 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1944 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
1950 return _bfd_elf_adjust_dynamic_copy (h
, s
);
1953 /* Allocate space in .plt, .got and associated reloc sections for
1957 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1959 struct bfd_link_info
*info
;
1960 struct elf_i386_link_hash_table
*htab
;
1961 struct elf_i386_link_hash_entry
*eh
;
1962 struct elf_i386_dyn_relocs
*p
;
1964 if (h
->root
.type
== bfd_link_hash_indirect
)
1967 if (h
->root
.type
== bfd_link_hash_warning
)
1968 /* When warning symbols are created, they **replace** the "real"
1969 entry in the hash table, thus we never get to see the real
1970 symbol in a hash traversal. So look at it now. */
1971 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1972 eh
= (struct elf_i386_link_hash_entry
*) h
;
1974 info
= (struct bfd_link_info
*) inf
;
1975 htab
= elf_i386_hash_table (info
);
1977 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1978 here if it is defined and referenced in a non-shared object. */
1979 if (h
->type
== STT_GNU_IFUNC
1982 asection
*plt
, *gotplt
, *relplt
;
1984 /* Return and discard space for dynamic relocations against it if
1985 it is never referenced in a non-shared object. */
1986 if (!h
->ref_regular
)
1988 if (h
->plt
.refcount
> 0
1989 || h
->got
.refcount
> 0)
1991 h
->got
.offset
= (bfd_vma
) -1;
1992 eh
->dyn_relocs
= NULL
;
1996 /* When building a static executable, use .iplt, .igot.plt and
1997 .rel.iplt sections for STT_GNU_IFUNC symbols. */
1998 if (htab
->splt
!= NULL
)
2001 gotplt
= htab
->sgotplt
;
2002 relplt
= htab
->srelplt
;
2004 /* If this is the first .plt entry, make room for the special
2007 plt
->size
+= PLT_ENTRY_SIZE
;
2012 gotplt
= htab
->igotplt
;
2013 relplt
= htab
->irelplt
;
2016 /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
2017 the original value for R_386_IRELATIVE. */
2018 h
->plt
.offset
= plt
->size
;
2020 /* Make room for this entry in the .plt/.iplt section. */
2021 plt
->size
+= PLT_ENTRY_SIZE
;
2023 /* We also need to make an entry in the .got.plt/.got.iplt
2024 section, which will be placed in the .got section by the
2028 /* We also need to make an entry in the .rela.plt/.rela.iplt
2030 relplt
->size
+= sizeof (Elf32_External_Rel
);
2031 relplt
->reloc_count
++;
2033 /* We need dynamic relocation for STT_GNU_IFUNC symbol only
2034 when there is a non-GOT reference in a shared object. */
2037 eh
->dyn_relocs
= NULL
;
2039 /* Finally, allocate space. */
2040 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2042 asection
* sreloc
= elf_section_data (p
->sec
)->sreloc
;
2043 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2046 /* For STT_GNU_IFUNC symbol, .got.plt has the real function
2047 addres and .got has the PLT entry adddress. We will load
2048 the GOT entry with the PLT entry in finish_dynamic_symbol if
2049 it is used. For branch, it uses .got.plt. For symbol value,
2050 1. Use .got.plt in a shared object if it is forced local or
2052 2. Use .got.plt in a non-shared object if pointer equality
2054 3. Use .got.plt if .got isn't used.
2055 4. Otherwise use .got so that it can be shared among different
2056 objects at run-time.
2057 We only need to relocate .got entry in shared object. */
2059 && (h
->dynindx
== -1
2060 || h
->forced_local
))
2062 && !h
->pointer_equality_needed
)
2063 || htab
->sgot
== NULL
)
2066 h
->got
.offset
= (bfd_vma
) -1;
2070 h
->got
.offset
= htab
->sgot
->size
;
2071 htab
->sgot
->size
+= 4;
2073 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2078 else if (htab
->elf
.dynamic_sections_created
2079 && h
->plt
.refcount
> 0)
2081 /* Make sure this symbol is output as a dynamic symbol.
2082 Undefined weak syms won't yet be marked as dynamic. */
2083 if (h
->dynindx
== -1
2084 && !h
->forced_local
)
2086 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2091 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2093 asection
*s
= htab
->splt
;
2095 /* If this is the first .plt entry, make room for the special
2098 s
->size
+= PLT_ENTRY_SIZE
;
2100 h
->plt
.offset
= s
->size
;
2102 /* If this symbol is not defined in a regular file, and we are
2103 not generating a shared library, then set the symbol to this
2104 location in the .plt. This is required to make function
2105 pointers compare as equal between the normal executable and
2106 the shared library. */
2110 h
->root
.u
.def
.section
= s
;
2111 h
->root
.u
.def
.value
= h
->plt
.offset
;
2114 /* Make room for this entry. */
2115 s
->size
+= PLT_ENTRY_SIZE
;
2117 /* We also need to make an entry in the .got.plt section, which
2118 will be placed in the .got section by the linker script. */
2119 htab
->sgotplt
->size
+= 4;
2121 /* We also need to make an entry in the .rel.plt section. */
2122 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2123 htab
->next_tls_desc_index
++;
2125 if (htab
->is_vxworks
&& !info
->shared
)
2127 /* VxWorks has a second set of relocations for each PLT entry
2128 in executables. They go in a separate relocation section,
2129 which is processed by the kernel loader. */
2131 /* There are two relocations for the initial PLT entry: an
2132 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2133 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2135 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
2136 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2138 /* There are two extra relocations for each subsequent PLT entry:
2139 an R_386_32 relocation for the GOT entry, and an R_386_32
2140 relocation for the PLT entry. */
2142 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2147 h
->plt
.offset
= (bfd_vma
) -1;
2153 h
->plt
.offset
= (bfd_vma
) -1;
2157 eh
->tlsdesc_got
= (bfd_vma
) -1;
2159 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2160 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2161 if (h
->got
.refcount
> 0
2164 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2165 h
->got
.offset
= (bfd_vma
) -1;
2166 else if (h
->got
.refcount
> 0)
2170 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2172 /* Make sure this symbol is output as a dynamic symbol.
2173 Undefined weak syms won't yet be marked as dynamic. */
2174 if (h
->dynindx
== -1
2175 && !h
->forced_local
)
2177 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2182 if (GOT_TLS_GDESC_P (tls_type
))
2184 eh
->tlsdesc_got
= htab
->sgotplt
->size
2185 - elf_i386_compute_jump_table_size (htab
);
2186 htab
->sgotplt
->size
+= 8;
2187 h
->got
.offset
= (bfd_vma
) -2;
2189 if (! GOT_TLS_GDESC_P (tls_type
)
2190 || GOT_TLS_GD_P (tls_type
))
2192 h
->got
.offset
= s
->size
;
2194 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2195 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2198 dyn
= htab
->elf
.dynamic_sections_created
;
2199 /* R_386_TLS_IE_32 needs one dynamic relocation,
2200 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2201 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2202 need two), R_386_TLS_GD needs one if local symbol and two if
2204 if (tls_type
== GOT_TLS_IE_BOTH
)
2205 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2206 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2207 || (tls_type
& GOT_TLS_IE
))
2208 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2209 else if (GOT_TLS_GD_P (tls_type
))
2210 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2211 else if (! GOT_TLS_GDESC_P (tls_type
)
2212 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2213 || h
->root
.type
!= bfd_link_hash_undefweak
)
2215 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2216 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2217 if (GOT_TLS_GDESC_P (tls_type
))
2218 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2221 h
->got
.offset
= (bfd_vma
) -1;
2223 if (eh
->dyn_relocs
== NULL
)
2226 /* In the shared -Bsymbolic case, discard space allocated for
2227 dynamic pc-relative relocs against symbols which turn out to be
2228 defined in regular objects. For the normal shared case, discard
2229 space for pc-relative relocs that have become local due to symbol
2230 visibility changes. */
2234 /* The only reloc that uses pc_count is R_386_PC32, which will
2235 appear on a call or on something like ".long foo - .". We
2236 want calls to protected symbols to resolve directly to the
2237 function rather than going via the plt. If people want
2238 function pointer comparisons to work as expected then they
2239 should avoid writing assembly like ".long foo - .". */
2240 if (SYMBOL_CALLS_LOCAL (info
, h
))
2242 struct elf_i386_dyn_relocs
**pp
;
2244 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2246 p
->count
-= p
->pc_count
;
2255 if (htab
->is_vxworks
)
2257 struct elf_i386_dyn_relocs
**pp
;
2258 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2260 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2267 /* Also discard relocs on undefined weak syms with non-default
2269 if (eh
->dyn_relocs
!= NULL
2270 && h
->root
.type
== bfd_link_hash_undefweak
)
2272 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2273 eh
->dyn_relocs
= NULL
;
2275 /* Make sure undefined weak symbols are output as a dynamic
2277 else if (h
->dynindx
== -1
2278 && !h
->forced_local
)
2280 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2285 else if (ELIMINATE_COPY_RELOCS
)
2287 /* For the non-shared case, discard space for relocs against
2288 symbols which turn out to need copy relocs or are not
2294 || (htab
->elf
.dynamic_sections_created
2295 && (h
->root
.type
== bfd_link_hash_undefweak
2296 || h
->root
.type
== bfd_link_hash_undefined
))))
2298 /* Make sure this symbol is output as a dynamic symbol.
2299 Undefined weak syms won't yet be marked as dynamic. */
2300 if (h
->dynindx
== -1
2301 && !h
->forced_local
)
2303 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2307 /* If that succeeded, we know we'll be keeping all the
2309 if (h
->dynindx
!= -1)
2313 eh
->dyn_relocs
= NULL
;
2318 /* Finally, allocate space. */
2319 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2323 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2325 BFD_ASSERT (sreloc
!= NULL
);
2326 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2332 /* Find any dynamic relocs that apply to read-only sections. */
2335 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2337 struct elf_i386_link_hash_entry
*eh
;
2338 struct elf_i386_dyn_relocs
*p
;
2340 if (h
->root
.type
== bfd_link_hash_warning
)
2341 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2343 eh
= (struct elf_i386_link_hash_entry
*) h
;
2344 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2346 asection
*s
= p
->sec
->output_section
;
2348 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2350 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2352 info
->flags
|= DF_TEXTREL
;
2354 /* Not an error, just cut short the traversal. */
2361 /* Set the sizes of the dynamic sections. */
2364 elf_i386_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2365 struct bfd_link_info
*info
)
2367 struct elf_i386_link_hash_table
*htab
;
2373 htab
= elf_i386_hash_table (info
);
2374 dynobj
= htab
->elf
.dynobj
;
2378 if (htab
->elf
.dynamic_sections_created
)
2380 /* Set the contents of the .interp section to the interpreter. */
2381 if (info
->executable
)
2383 s
= bfd_get_section_by_name (dynobj
, ".interp");
2386 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2387 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2391 /* Set up .got offsets for local syms, and space for local dynamic
2393 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2395 bfd_signed_vma
*local_got
;
2396 bfd_signed_vma
*end_local_got
;
2397 char *local_tls_type
;
2398 bfd_vma
*local_tlsdesc_gotent
;
2399 bfd_size_type locsymcount
;
2400 Elf_Internal_Shdr
*symtab_hdr
;
2403 if (! is_i386_elf (ibfd
))
2406 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2408 struct elf_i386_dyn_relocs
*p
;
2410 for (p
= ((struct elf_i386_dyn_relocs
*)
2411 elf_section_data (s
)->local_dynrel
);
2415 if (!bfd_is_abs_section (p
->sec
)
2416 && bfd_is_abs_section (p
->sec
->output_section
))
2418 /* Input section has been discarded, either because
2419 it is a copy of a linkonce section or due to
2420 linker script /DISCARD/, so we'll be discarding
2423 else if (htab
->is_vxworks
2424 && strcmp (p
->sec
->output_section
->name
,
2427 /* Relocations in vxworks .tls_vars sections are
2428 handled specially by the loader. */
2430 else if (p
->count
!= 0)
2432 srel
= elf_section_data (p
->sec
)->sreloc
;
2433 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2434 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2435 info
->flags
|= DF_TEXTREL
;
2440 local_got
= elf_local_got_refcounts (ibfd
);
2444 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2445 locsymcount
= symtab_hdr
->sh_info
;
2446 end_local_got
= local_got
+ locsymcount
;
2447 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
2448 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
2450 srel
= htab
->srelgot
;
2451 for (; local_got
< end_local_got
;
2452 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2454 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2457 if (GOT_TLS_GDESC_P (*local_tls_type
))
2459 *local_tlsdesc_gotent
= htab
->sgotplt
->size
2460 - elf_i386_compute_jump_table_size (htab
);
2461 htab
->sgotplt
->size
+= 8;
2462 *local_got
= (bfd_vma
) -2;
2464 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2465 || GOT_TLS_GD_P (*local_tls_type
))
2467 *local_got
= s
->size
;
2469 if (GOT_TLS_GD_P (*local_tls_type
)
2470 || *local_tls_type
== GOT_TLS_IE_BOTH
)
2474 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2475 || (*local_tls_type
& GOT_TLS_IE
))
2477 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
2478 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
2479 else if (GOT_TLS_GD_P (*local_tls_type
)
2480 || ! GOT_TLS_GDESC_P (*local_tls_type
))
2481 srel
->size
+= sizeof (Elf32_External_Rel
);
2482 if (GOT_TLS_GDESC_P (*local_tls_type
))
2483 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2487 *local_got
= (bfd_vma
) -1;
2491 if (htab
->tls_ldm_got
.refcount
> 0)
2493 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2495 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2496 htab
->sgot
->size
+= 8;
2497 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2500 htab
->tls_ldm_got
.offset
= -1;
2502 /* Allocate global sym .plt and .got entries, and space for global
2503 sym dynamic relocs. */
2504 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
2506 /* For every jump slot reserved in the sgotplt, reloc_count is
2507 incremented. However, when we reserve space for TLS descriptors,
2508 it's not incremented, so in order to compute the space reserved
2509 for them, it suffices to multiply the reloc count by the jump
2512 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
2514 /* We now have determined the sizes of the various dynamic sections.
2515 Allocate memory for them. */
2517 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2519 bfd_boolean strip_section
= TRUE
;
2521 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2526 || s
== htab
->sgotplt
2528 || s
== htab
->igotplt
2529 || s
== htab
->sdynbss
)
2531 /* Strip this section if we don't need it; see the
2533 /* We'd like to strip these sections if they aren't needed, but if
2534 we've exported dynamic symbols from them we must leave them.
2535 It's too late to tell BFD to get rid of the symbols. */
2537 if (htab
->elf
.hplt
!= NULL
)
2538 strip_section
= FALSE
;
2540 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
2542 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
2545 /* We use the reloc_count field as a counter if we need
2546 to copy relocs into the output file. */
2551 /* It's not one of our sections, so don't allocate space. */
2557 /* If we don't need this section, strip it from the
2558 output file. This is mostly to handle .rel.bss and
2559 .rel.plt. We must create both sections in
2560 create_dynamic_sections, because they must be created
2561 before the linker maps input sections to output
2562 sections. The linker does that before
2563 adjust_dynamic_symbol is called, and it is that
2564 function which decides whether anything needs to go
2565 into these sections. */
2567 s
->flags
|= SEC_EXCLUDE
;
2571 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2574 /* Allocate memory for the section contents. We use bfd_zalloc
2575 here in case unused entries are not reclaimed before the
2576 section's contents are written out. This should not happen,
2577 but this way if it does, we get a R_386_NONE reloc instead
2579 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2580 if (s
->contents
== NULL
)
2584 if (htab
->elf
.dynamic_sections_created
)
2586 /* Add some entries to the .dynamic section. We fill in the
2587 values later, in elf_i386_finish_dynamic_sections, but we
2588 must add the entries now so that we get the correct size for
2589 the .dynamic section. The DT_DEBUG entry is filled in by the
2590 dynamic linker and used by the debugger. */
2591 #define add_dynamic_entry(TAG, VAL) \
2592 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2594 if (info
->executable
)
2596 if (!add_dynamic_entry (DT_DEBUG
, 0))
2600 if (htab
->splt
->size
!= 0)
2602 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2603 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2604 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2605 || !add_dynamic_entry (DT_JMPREL
, 0))
2611 if (!add_dynamic_entry (DT_REL
, 0)
2612 || !add_dynamic_entry (DT_RELSZ
, 0)
2613 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2616 /* If any dynamic relocs apply to a read-only section,
2617 then we need a DT_TEXTREL entry. */
2618 if ((info
->flags
& DF_TEXTREL
) == 0)
2619 elf_link_hash_traverse (&htab
->elf
,
2620 elf_i386_readonly_dynrelocs
, info
);
2622 if ((info
->flags
& DF_TEXTREL
) != 0)
2624 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2628 if (htab
->is_vxworks
2629 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
2632 #undef add_dynamic_entry
2638 elf_i386_always_size_sections (bfd
*output_bfd
,
2639 struct bfd_link_info
*info
)
2641 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2645 struct elf_link_hash_entry
*tlsbase
;
2647 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2648 "_TLS_MODULE_BASE_",
2649 FALSE
, FALSE
, FALSE
);
2651 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2653 struct bfd_link_hash_entry
*bh
= NULL
;
2654 const struct elf_backend_data
*bed
2655 = get_elf_backend_data (output_bfd
);
2657 if (!(_bfd_generic_link_add_one_symbol
2658 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2659 tls_sec
, 0, NULL
, FALSE
,
2660 bed
->collect
, &bh
)))
2663 elf_i386_hash_table (info
)->tls_module_base
= bh
;
2665 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2666 tlsbase
->def_regular
= 1;
2667 tlsbase
->other
= STV_HIDDEN
;
2668 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2675 /* Set the correct type for an x86 ELF section. We do this by the
2676 section name, which is a hack, but ought to work. */
2679 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2680 Elf_Internal_Shdr
*hdr
,
2683 register const char *name
;
2685 name
= bfd_get_section_name (abfd
, sec
);
2687 /* This is an ugly, but unfortunately necessary hack that is
2688 needed when producing EFI binaries on x86. It tells
2689 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2690 containing ELF relocation info. We need this hack in order to
2691 be able to generate ELF binaries that can be translated into
2692 EFI applications (which are essentially COFF objects). Those
2693 files contain a COFF ".reloc" section inside an ELFNN object,
2694 which would normally cause BFD to segfault because it would
2695 attempt to interpret this section as containing relocation
2696 entries for section "oc". With this hack enabled, ".reloc"
2697 will be treated as a normal data section, which will avoid the
2698 segfault. However, you won't be able to create an ELFNN binary
2699 with a section named "oc" that needs relocations, but that's
2700 the kind of ugly side-effects you get when detecting section
2701 types based on their names... In practice, this limitation is
2702 unlikely to bite. */
2703 if (strcmp (name
, ".reloc") == 0)
2704 hdr
->sh_type
= SHT_PROGBITS
;
2709 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2710 executables. Rather than setting it to the beginning of the TLS
2711 section, we have to set it to the end. This function may be called
2712 multiple times, it is idempotent. */
2715 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
2717 struct bfd_link_hash_entry
*base
;
2719 if (!info
->executable
)
2722 base
= elf_i386_hash_table (info
)->tls_module_base
;
2727 base
->u
.def
.value
= elf_hash_table (info
)->tls_size
;
2730 /* Return the base VMA address which should be subtracted from real addresses
2731 when resolving @dtpoff relocation.
2732 This is PT_TLS segment p_vaddr. */
2735 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
2737 /* If tls_sec is NULL, we should have signalled an error already. */
2738 if (elf_hash_table (info
)->tls_sec
== NULL
)
2740 return elf_hash_table (info
)->tls_sec
->vma
;
2743 /* Return the relocation value for @tpoff relocation
2744 if STT_TLS virtual address is ADDRESS. */
2747 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2749 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2751 /* If tls_sec is NULL, we should have signalled an error already. */
2752 if (htab
->tls_sec
== NULL
)
2754 return htab
->tls_size
+ htab
->tls_sec
->vma
- address
;
2757 /* Relocate an i386 ELF section. */
2760 elf_i386_relocate_section (bfd
*output_bfd
,
2761 struct bfd_link_info
*info
,
2763 asection
*input_section
,
2765 Elf_Internal_Rela
*relocs
,
2766 Elf_Internal_Sym
*local_syms
,
2767 asection
**local_sections
)
2769 struct elf_i386_link_hash_table
*htab
;
2770 Elf_Internal_Shdr
*symtab_hdr
;
2771 struct elf_link_hash_entry
**sym_hashes
;
2772 bfd_vma
*local_got_offsets
;
2773 bfd_vma
*local_tlsdesc_gotents
;
2774 Elf_Internal_Rela
*rel
;
2775 Elf_Internal_Rela
*relend
;
2776 bfd_boolean is_vxworks_tls
;
2778 BFD_ASSERT (is_i386_elf (input_bfd
));
2780 htab
= elf_i386_hash_table (info
);
2781 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2782 sym_hashes
= elf_sym_hashes (input_bfd
);
2783 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2784 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2785 /* We have to handle relocations in vxworks .tls_vars sections
2786 specially, because the dynamic loader is 'weird'. */
2787 is_vxworks_tls
= (htab
->is_vxworks
&& info
->shared
2788 && !strcmp (input_section
->output_section
->name
,
2791 elf_i386_set_tls_module_base (info
);
2794 relend
= relocs
+ input_section
->reloc_count
;
2795 for (; rel
< relend
; rel
++)
2797 unsigned int r_type
;
2798 reloc_howto_type
*howto
;
2799 unsigned long r_symndx
;
2800 struct elf_link_hash_entry
*h
;
2801 Elf_Internal_Sym
*sym
;
2803 bfd_vma off
, offplt
;
2805 bfd_boolean unresolved_reloc
;
2806 bfd_reloc_status_type r
;
2810 r_type
= ELF32_R_TYPE (rel
->r_info
);
2811 if (r_type
== R_386_GNU_VTINHERIT
2812 || r_type
== R_386_GNU_VTENTRY
)
2815 if ((indx
= r_type
) >= R_386_standard
2816 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2817 >= R_386_ext
- R_386_standard
)
2818 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2819 >= R_386_irelative
- R_386_ext
))
2821 (*_bfd_error_handler
)
2822 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2823 input_bfd
, input_section
, r_type
);
2824 bfd_set_error (bfd_error_bad_value
);
2827 howto
= elf_howto_table
+ indx
;
2829 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2833 unresolved_reloc
= FALSE
;
2834 if (r_symndx
< symtab_hdr
->sh_info
)
2836 sym
= local_syms
+ r_symndx
;
2837 sec
= local_sections
[r_symndx
];
2838 relocation
= (sec
->output_section
->vma
2839 + sec
->output_offset
2842 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
2843 && ((sec
->flags
& SEC_MERGE
) != 0
2844 || (info
->relocatable
2845 && sec
->output_offset
!= 0)))
2848 bfd_byte
*where
= contents
+ rel
->r_offset
;
2850 switch (howto
->size
)
2853 addend
= bfd_get_8 (input_bfd
, where
);
2854 if (howto
->pc_relative
)
2856 addend
= (addend
^ 0x80) - 0x80;
2861 addend
= bfd_get_16 (input_bfd
, where
);
2862 if (howto
->pc_relative
)
2864 addend
= (addend
^ 0x8000) - 0x8000;
2869 addend
= bfd_get_32 (input_bfd
, where
);
2870 if (howto
->pc_relative
)
2872 addend
= (addend
^ 0x80000000) - 0x80000000;
2880 if (info
->relocatable
)
2881 addend
+= sec
->output_offset
;
2884 asection
*msec
= sec
;
2885 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
2887 addend
-= relocation
;
2888 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2891 switch (howto
->size
)
2894 /* FIXME: overflow checks. */
2895 if (howto
->pc_relative
)
2897 bfd_put_8 (input_bfd
, addend
, where
);
2900 if (howto
->pc_relative
)
2902 bfd_put_16 (input_bfd
, addend
, where
);
2905 if (howto
->pc_relative
)
2907 bfd_put_32 (input_bfd
, addend
, where
);
2916 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2917 r_symndx
, symtab_hdr
, sym_hashes
,
2919 unresolved_reloc
, warned
);
2922 if (sec
!= NULL
&& elf_discarded_section (sec
))
2924 /* For relocs against symbols from removed linkonce sections,
2925 or sections discarded by a linker script, we just want the
2926 section contents zeroed. Avoid any special processing. */
2927 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2933 if (info
->relocatable
)
2936 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2937 it here if it is defined in a non-shared object. */
2939 && h
->type
== STT_GNU_IFUNC
2942 asection
*plt
, *gotplt
, *base_got
;
2945 if ((input_section
->flags
& SEC_ALLOC
) == 0
2946 || h
->plt
.offset
== (bfd_vma
) -1)
2949 /* STT_GNU_IFUNC symbol must go through PLT. */
2950 if (htab
->splt
!= NULL
)
2953 gotplt
= htab
->sgotplt
;
2958 gotplt
= htab
->igotplt
;
2961 relocation
= (plt
->output_section
->vma
2962 + plt
->output_offset
+ h
->plt
.offset
);
2967 (*_bfd_error_handler
)
2968 (_("%B: relocation %s against STT_GNU_IFUNC "
2969 "symbol `%s' isn't handled by %s"), input_bfd
,
2970 elf_howto_table
[r_type
].name
,
2971 h
->root
.root
.string
, __FUNCTION__
);
2972 bfd_set_error (bfd_error_bad_value
);
2976 /* Generate dynamic relcoation only when there is a
2977 non-GOF reference in a shared object. */
2978 if (info
->shared
&& h
->non_got_ref
)
2980 Elf_Internal_Rela outrel
;
2985 /* Need a dynamic relocation get the the real
2986 function adddress. */
2987 offset
= _bfd_elf_section_offset (output_bfd
,
2991 if (offset
== (bfd_vma
) -1
2992 || offset
== (bfd_vma
) -2)
2995 outrel
.r_offset
= (input_section
->output_section
->vma
2996 + input_section
->output_offset
2999 if (h
->dynindx
== -1
3002 /* This symbol is resolved locally. */
3003 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3004 bfd_put_32 (output_bfd
,
3005 (h
->root
.u
.def
.value
3006 + h
->root
.u
.def
.section
->output_section
->vma
3007 + h
->root
.u
.def
.section
->output_offset
),
3011 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3013 sreloc
= elf_section_data (input_section
)->sreloc
;
3014 loc
= sreloc
->contents
;
3015 loc
+= (sreloc
->reloc_count
++
3016 * sizeof (Elf32_External_Rel
));
3017 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3019 /* If this reloc is against an external symbol, we
3020 do not want to fiddle with the addend. Otherwise,
3021 we need to include the symbol value so that it
3022 becomes an addend for the dynamic reloc. For an
3023 internal symbol, we have updated addend. */
3032 base_got
= htab
->sgot
;
3033 off
= h
->got
.offset
;
3035 if (base_got
== NULL
)
3038 if (off
== (bfd_vma
) -1)
3040 /* We can't use h->got.offset here to save state, or
3041 even just remember the offset, as finish_dynamic_symbol
3042 would use that as offset into .got. */
3044 if (htab
->splt
!= NULL
)
3046 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3047 off
= (plt_index
+ 3) * 4;
3048 base_got
= htab
->sgotplt
;
3052 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3053 off
= plt_index
* 4;
3054 base_got
= htab
->igotplt
;
3057 if (h
->dynindx
== -1
3061 /* This references the local defitionion. We must
3062 initialize this entry in the global offset table.
3063 Since the offset must always be a multiple of 8,
3064 we use the least significant bit to record
3065 whether we have initialized it already.
3067 When doing a dynamic link, we create a .rela.got
3068 relocation entry to initialize the value. This
3069 is done in the finish_dynamic_symbol routine. */
3074 bfd_put_32 (output_bfd
, relocation
,
3075 base_got
->contents
+ off
);
3082 /* Adjust for static executables. */
3083 if (htab
->splt
== NULL
)
3084 relocation
+= gotplt
->output_offset
;
3088 relocation
= (base_got
->output_section
->vma
3089 + base_got
->output_offset
+ off
3090 - gotplt
->output_section
->vma
3091 - gotplt
->output_offset
);
3092 /* Adjust for static executables. */
3093 if (htab
->splt
== NULL
)
3094 relocation
+= gotplt
->output_offset
;
3100 relocation
-= (gotplt
->output_section
->vma
3101 + gotplt
->output_offset
);
3109 /* Relocation is to the entry for this symbol in the global
3111 if (htab
->sgot
== NULL
)
3118 off
= h
->got
.offset
;
3119 dyn
= htab
->elf
.dynamic_sections_created
;
3120 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3122 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3123 || (ELF_ST_VISIBILITY (h
->other
)
3124 && h
->root
.type
== bfd_link_hash_undefweak
))
3126 /* This is actually a static link, or it is a
3127 -Bsymbolic link and the symbol is defined
3128 locally, or the symbol was forced to be local
3129 because of a version file. We must initialize
3130 this entry in the global offset table. Since the
3131 offset must always be a multiple of 4, we use the
3132 least significant bit to record whether we have
3133 initialized it already.
3135 When doing a dynamic link, we create a .rel.got
3136 relocation entry to initialize the value. This
3137 is done in the finish_dynamic_symbol routine. */
3142 bfd_put_32 (output_bfd
, relocation
,
3143 htab
->sgot
->contents
+ off
);
3148 unresolved_reloc
= FALSE
;
3152 if (local_got_offsets
== NULL
)
3155 off
= local_got_offsets
[r_symndx
];
3157 /* The offset must always be a multiple of 4. We use
3158 the least significant bit to record whether we have
3159 already generated the necessary reloc. */
3164 bfd_put_32 (output_bfd
, relocation
,
3165 htab
->sgot
->contents
+ off
);
3170 Elf_Internal_Rela outrel
;
3177 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3178 + htab
->sgot
->output_offset
3180 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3182 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3183 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3186 local_got_offsets
[r_symndx
] |= 1;
3190 if (off
>= (bfd_vma
) -2)
3193 relocation
= htab
->sgot
->output_section
->vma
3194 + htab
->sgot
->output_offset
+ off
3195 - htab
->sgotplt
->output_section
->vma
3196 - htab
->sgotplt
->output_offset
;
3200 /* Relocation is relative to the start of the global offset
3203 /* Check to make sure it isn't a protected function symbol
3204 for shared library since it may not be local when used
3205 as function address. We also need to make sure that a
3206 symbol is defined locally. */
3207 if (info
->shared
&& h
)
3209 if (!h
->def_regular
)
3213 switch (ELF_ST_VISIBILITY (h
->other
))
3216 v
= _("hidden symbol");
3219 v
= _("internal symbol");
3222 v
= _("protected symbol");
3229 (*_bfd_error_handler
)
3230 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3231 input_bfd
, v
, h
->root
.root
.string
);
3232 bfd_set_error (bfd_error_bad_value
);
3235 else if (!info
->executable
3236 && h
->type
== STT_FUNC
3237 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3239 (*_bfd_error_handler
)
3240 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3241 input_bfd
, h
->root
.root
.string
);
3242 bfd_set_error (bfd_error_bad_value
);
3247 /* Note that sgot is not involved in this
3248 calculation. We always want the start of .got.plt. If we
3249 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3250 permitted by the ABI, we might have to change this
3252 relocation
-= htab
->sgotplt
->output_section
->vma
3253 + htab
->sgotplt
->output_offset
;
3257 /* Use global offset table as symbol value. */
3258 relocation
= htab
->sgotplt
->output_section
->vma
3259 + htab
->sgotplt
->output_offset
;
3260 unresolved_reloc
= FALSE
;
3264 /* Relocation is to the entry for this symbol in the
3265 procedure linkage table. */
3267 /* Resolve a PLT32 reloc against a local symbol directly,
3268 without using the procedure linkage table. */
3272 if (h
->plt
.offset
== (bfd_vma
) -1
3273 || htab
->splt
== NULL
)
3275 /* We didn't make a PLT entry for this symbol. This
3276 happens when statically linking PIC code, or when
3277 using -Bsymbolic. */
3281 relocation
= (htab
->splt
->output_section
->vma
3282 + htab
->splt
->output_offset
3284 unresolved_reloc
= FALSE
;
3289 if ((input_section
->flags
& SEC_ALLOC
) == 0
3295 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3296 || h
->root
.type
!= bfd_link_hash_undefweak
)
3297 && (r_type
!= R_386_PC32
3298 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3299 || (ELIMINATE_COPY_RELOCS
3306 || h
->root
.type
== bfd_link_hash_undefweak
3307 || h
->root
.type
== bfd_link_hash_undefined
)))
3309 Elf_Internal_Rela outrel
;
3311 bfd_boolean skip
, relocate
;
3314 /* When generating a shared object, these relocations
3315 are copied into the output file to be resolved at run
3322 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3324 if (outrel
.r_offset
== (bfd_vma
) -1)
3326 else if (outrel
.r_offset
== (bfd_vma
) -2)
3327 skip
= TRUE
, relocate
= TRUE
;
3328 outrel
.r_offset
+= (input_section
->output_section
->vma
3329 + input_section
->output_offset
);
3332 memset (&outrel
, 0, sizeof outrel
);
3335 && (r_type
== R_386_PC32
3337 || !SYMBOLIC_BIND (info
, h
)
3338 || !h
->def_regular
))
3339 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3342 /* This symbol is local, or marked to become local. */
3344 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3347 sreloc
= elf_section_data (input_section
)->sreloc
;
3349 BFD_ASSERT (sreloc
!= NULL
&& sreloc
->contents
!= NULL
);
3351 loc
= sreloc
->contents
;
3352 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3354 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3356 /* If this reloc is against an external symbol, we do
3357 not want to fiddle with the addend. Otherwise, we
3358 need to include the symbol value so that it becomes
3359 an addend for the dynamic reloc. */
3368 Elf_Internal_Rela outrel
;
3372 outrel
.r_offset
= rel
->r_offset
3373 + input_section
->output_section
->vma
3374 + input_section
->output_offset
;
3375 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3376 sreloc
= elf_section_data (input_section
)->sreloc
;
3379 loc
= sreloc
->contents
;
3380 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3381 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3386 case R_386_TLS_GOTDESC
:
3387 case R_386_TLS_DESC_CALL
:
3388 case R_386_TLS_IE_32
:
3389 case R_386_TLS_GOTIE
:
3390 tls_type
= GOT_UNKNOWN
;
3391 if (h
== NULL
&& local_got_offsets
)
3392 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
3394 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
3395 if (tls_type
== GOT_TLS_IE
)
3396 tls_type
= GOT_TLS_IE_NEG
;
3398 if (! elf_i386_tls_transition (info
, input_bfd
,
3399 input_section
, contents
,
3400 symtab_hdr
, sym_hashes
,
3401 &r_type
, tls_type
, rel
,
3405 if (r_type
== R_386_TLS_LE_32
)
3407 BFD_ASSERT (! unresolved_reloc
);
3408 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3413 /* GD->LE transition. */
3414 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3417 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3419 movl %gs:0, %eax; subl $foo@tpoff, %eax
3420 (6 byte form of subl). */
3421 memcpy (contents
+ rel
->r_offset
- 3,
3422 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3423 roff
= rel
->r_offset
+ 5;
3427 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3429 movl %gs:0, %eax; subl $foo@tpoff, %eax
3430 (6 byte form of subl). */
3431 memcpy (contents
+ rel
->r_offset
- 2,
3432 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3433 roff
= rel
->r_offset
+ 6;
3435 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3437 /* Skip R_386_PC32/R_386_PLT32. */
3441 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3443 /* GDesc -> LE transition.
3444 It's originally something like:
3445 leal x@tlsdesc(%ebx), %eax
3449 Registers other than %eax may be set up here. */
3454 roff
= rel
->r_offset
;
3455 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3457 /* Now modify the instruction as appropriate. */
3458 /* aoliva FIXME: remove the above and xor the byte
3460 bfd_put_8 (output_bfd
, val
^ 0x86,
3461 contents
+ roff
- 1);
3462 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3466 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3468 /* GDesc -> LE transition.
3476 roff
= rel
->r_offset
;
3477 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3478 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3481 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
3485 /* IE->LE transition:
3486 Originally it can be one of:
3494 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3497 /* movl foo, %eax. */
3498 bfd_put_8 (output_bfd
, 0xb8,
3499 contents
+ rel
->r_offset
- 1);
3505 type
= bfd_get_8 (input_bfd
,
3506 contents
+ rel
->r_offset
- 2);
3511 bfd_put_8 (output_bfd
, 0xc7,
3512 contents
+ rel
->r_offset
- 2);
3513 bfd_put_8 (output_bfd
,
3514 0xc0 | ((val
>> 3) & 7),
3515 contents
+ rel
->r_offset
- 1);
3519 bfd_put_8 (output_bfd
, 0x81,
3520 contents
+ rel
->r_offset
- 2);
3521 bfd_put_8 (output_bfd
,
3522 0xc0 | ((val
>> 3) & 7),
3523 contents
+ rel
->r_offset
- 1);
3530 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3531 contents
+ rel
->r_offset
);
3536 unsigned int val
, type
;
3538 /* {IE_32,GOTIE}->LE transition:
3539 Originally it can be one of:
3540 subl foo(%reg1), %reg2
3541 movl foo(%reg1), %reg2
3542 addl foo(%reg1), %reg2
3545 movl $foo, %reg2 (6 byte form)
3546 addl $foo, %reg2. */
3547 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3548 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3552 bfd_put_8 (output_bfd
, 0xc7,
3553 contents
+ rel
->r_offset
- 2);
3554 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3555 contents
+ rel
->r_offset
- 1);
3557 else if (type
== 0x2b)
3560 bfd_put_8 (output_bfd
, 0x81,
3561 contents
+ rel
->r_offset
- 2);
3562 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
3563 contents
+ rel
->r_offset
- 1);
3565 else if (type
== 0x03)
3568 bfd_put_8 (output_bfd
, 0x81,
3569 contents
+ rel
->r_offset
- 2);
3570 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3571 contents
+ rel
->r_offset
- 1);
3575 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
3576 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3577 contents
+ rel
->r_offset
);
3579 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3580 contents
+ rel
->r_offset
);
3585 if (htab
->sgot
== NULL
)
3590 off
= h
->got
.offset
;
3591 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
3595 if (local_got_offsets
== NULL
)
3598 off
= local_got_offsets
[r_symndx
];
3599 offplt
= local_tlsdesc_gotents
[r_symndx
];
3606 Elf_Internal_Rela outrel
;
3611 if (htab
->srelgot
== NULL
)
3614 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3616 if (GOT_TLS_GDESC_P (tls_type
))
3618 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
3619 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
3620 <= htab
->sgotplt
->size
);
3621 outrel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3622 + htab
->sgotplt
->output_offset
3624 + htab
->sgotplt_jump_table_size
);
3625 sreloc
= htab
->srelplt
;
3626 loc
= sreloc
->contents
;
3627 loc
+= (htab
->next_tls_desc_index
++
3628 * sizeof (Elf32_External_Rel
));
3629 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3630 <= sreloc
->contents
+ sreloc
->size
);
3631 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3634 BFD_ASSERT (! unresolved_reloc
);
3635 bfd_put_32 (output_bfd
,
3636 relocation
- elf_i386_dtpoff_base (info
),
3637 htab
->sgotplt
->contents
+ offplt
3638 + htab
->sgotplt_jump_table_size
+ 4);
3642 bfd_put_32 (output_bfd
, 0,
3643 htab
->sgotplt
->contents
+ offplt
3644 + htab
->sgotplt_jump_table_size
+ 4);
3648 sreloc
= htab
->srelgot
;
3650 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3651 + htab
->sgot
->output_offset
+ off
);
3653 if (GOT_TLS_GD_P (tls_type
))
3654 dr_type
= R_386_TLS_DTPMOD32
;
3655 else if (GOT_TLS_GDESC_P (tls_type
))
3657 else if (tls_type
== GOT_TLS_IE_POS
)
3658 dr_type
= R_386_TLS_TPOFF
;
3660 dr_type
= R_386_TLS_TPOFF32
;
3662 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3663 bfd_put_32 (output_bfd
,
3664 relocation
- elf_i386_dtpoff_base (info
),
3665 htab
->sgot
->contents
+ off
);
3666 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3667 bfd_put_32 (output_bfd
,
3668 elf_i386_dtpoff_base (info
) - relocation
,
3669 htab
->sgot
->contents
+ off
);
3670 else if (dr_type
!= R_386_TLS_DESC
)
3671 bfd_put_32 (output_bfd
, 0,
3672 htab
->sgot
->contents
+ off
);
3673 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3675 loc
= sreloc
->contents
;
3676 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3677 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3678 <= sreloc
->contents
+ sreloc
->size
);
3679 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3681 if (GOT_TLS_GD_P (tls_type
))
3685 BFD_ASSERT (! unresolved_reloc
);
3686 bfd_put_32 (output_bfd
,
3687 relocation
- elf_i386_dtpoff_base (info
),
3688 htab
->sgot
->contents
+ off
+ 4);
3692 bfd_put_32 (output_bfd
, 0,
3693 htab
->sgot
->contents
+ off
+ 4);
3694 outrel
.r_info
= ELF32_R_INFO (indx
,
3695 R_386_TLS_DTPOFF32
);
3696 outrel
.r_offset
+= 4;
3697 sreloc
->reloc_count
++;
3698 loc
+= sizeof (Elf32_External_Rel
);
3699 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3700 <= sreloc
->contents
+ sreloc
->size
);
3701 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3704 else if (tls_type
== GOT_TLS_IE_BOTH
)
3706 bfd_put_32 (output_bfd
,
3708 ? relocation
- elf_i386_dtpoff_base (info
)
3710 htab
->sgot
->contents
+ off
+ 4);
3711 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3712 outrel
.r_offset
+= 4;
3713 sreloc
->reloc_count
++;
3714 loc
+= sizeof (Elf32_External_Rel
);
3715 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3722 local_got_offsets
[r_symndx
] |= 1;
3725 if (off
>= (bfd_vma
) -2
3726 && ! GOT_TLS_GDESC_P (tls_type
))
3728 if (r_type
== R_386_TLS_GOTDESC
3729 || r_type
== R_386_TLS_DESC_CALL
)
3731 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3732 unresolved_reloc
= FALSE
;
3734 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3736 bfd_vma g_o_t
= htab
->sgotplt
->output_section
->vma
3737 + htab
->sgotplt
->output_offset
;
3738 relocation
= htab
->sgot
->output_section
->vma
3739 + htab
->sgot
->output_offset
+ off
- g_o_t
;
3740 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3741 && tls_type
== GOT_TLS_IE_BOTH
)
3743 if (r_type
== R_386_TLS_IE
)
3744 relocation
+= g_o_t
;
3745 unresolved_reloc
= FALSE
;
3747 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3749 unsigned int val
, type
;
3752 /* GD->IE transition. */
3753 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3754 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3757 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3759 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3761 roff
= rel
->r_offset
- 3;
3765 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3767 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3768 roff
= rel
->r_offset
- 2;
3770 memcpy (contents
+ roff
,
3771 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3772 contents
[roff
+ 7] = 0x80 | (val
& 7);
3773 /* If foo is used only with foo@gotntpoff(%reg) and
3774 foo@indntpoff, but not with foo@gottpoff(%reg), change
3775 subl $foo@gottpoff(%reg), %eax
3777 addl $foo@gotntpoff(%reg), %eax. */
3778 if (tls_type
== GOT_TLS_IE_POS
)
3779 contents
[roff
+ 6] = 0x03;
3780 bfd_put_32 (output_bfd
,
3781 htab
->sgot
->output_section
->vma
3782 + htab
->sgot
->output_offset
+ off
3783 - htab
->sgotplt
->output_section
->vma
3784 - htab
->sgotplt
->output_offset
,
3785 contents
+ roff
+ 8);
3786 /* Skip R_386_PLT32. */
3790 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3792 /* GDesc -> IE transition.
3793 It's originally something like:
3794 leal x@tlsdesc(%ebx), %eax
3797 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3799 movl x@gottpoff(%ebx), %eax # before negl %eax
3801 Registers other than %eax may be set up here. */
3805 /* First, make sure it's a leal adding ebx to a 32-bit
3806 offset into any register, although it's probably
3807 almost always going to be eax. */
3808 roff
= rel
->r_offset
;
3810 /* Now modify the instruction as appropriate. */
3811 /* To turn a leal into a movl in the form we use it, it
3812 suffices to change the first byte from 0x8d to 0x8b.
3813 aoliva FIXME: should we decide to keep the leal, all
3814 we have to do is remove the statement below, and
3815 adjust the relaxation of R_386_TLS_DESC_CALL. */
3816 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3818 if (tls_type
== GOT_TLS_IE_BOTH
)
3821 bfd_put_32 (output_bfd
,
3822 htab
->sgot
->output_section
->vma
3823 + htab
->sgot
->output_offset
+ off
3824 - htab
->sgotplt
->output_section
->vma
3825 - htab
->sgotplt
->output_offset
,
3829 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3831 /* GDesc -> IE transition.
3839 depending on how we transformed the TLS_GOTDESC above.
3844 roff
= rel
->r_offset
;
3846 /* Now modify the instruction as appropriate. */
3847 if (tls_type
!= GOT_TLS_IE_NEG
)
3850 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3851 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3856 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
3857 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
3867 if (! elf_i386_tls_transition (info
, input_bfd
,
3868 input_section
, contents
,
3869 symtab_hdr
, sym_hashes
,
3870 &r_type
, GOT_UNKNOWN
, rel
,
3874 if (r_type
!= R_386_TLS_LDM
)
3876 /* LD->LE transition:
3877 leal foo(%reg), %eax; call ___tls_get_addr.
3879 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3880 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
3881 memcpy (contents
+ rel
->r_offset
- 2,
3882 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3883 /* Skip R_386_PC32/R_386_PLT32. */
3888 if (htab
->sgot
== NULL
)
3891 off
= htab
->tls_ldm_got
.offset
;
3896 Elf_Internal_Rela outrel
;
3899 if (htab
->srelgot
== NULL
)
3902 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3903 + htab
->sgot
->output_offset
+ off
);
3905 bfd_put_32 (output_bfd
, 0,
3906 htab
->sgot
->contents
+ off
);
3907 bfd_put_32 (output_bfd
, 0,
3908 htab
->sgot
->contents
+ off
+ 4);
3909 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
3910 loc
= htab
->srelgot
->contents
;
3911 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3912 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3913 htab
->tls_ldm_got
.offset
|= 1;
3915 relocation
= htab
->sgot
->output_section
->vma
3916 + htab
->sgot
->output_offset
+ off
3917 - htab
->sgotplt
->output_section
->vma
3918 - htab
->sgotplt
->output_offset
;
3919 unresolved_reloc
= FALSE
;
3922 case R_386_TLS_LDO_32
:
3923 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
3924 relocation
-= elf_i386_dtpoff_base (info
);
3926 /* When converting LDO to LE, we must negate. */
3927 relocation
= -elf_i386_tpoff (info
, relocation
);
3930 case R_386_TLS_LE_32
:
3934 Elf_Internal_Rela outrel
;
3939 outrel
.r_offset
= rel
->r_offset
3940 + input_section
->output_section
->vma
3941 + input_section
->output_offset
;
3942 if (h
!= NULL
&& h
->dynindx
!= -1)
3946 if (r_type
== R_386_TLS_LE_32
)
3947 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
3949 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3950 sreloc
= elf_section_data (input_section
)->sreloc
;
3953 loc
= sreloc
->contents
;
3954 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3955 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3958 else if (r_type
== R_386_TLS_LE_32
)
3959 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
3961 relocation
-= elf_i386_dtpoff_base (info
);
3963 else if (r_type
== R_386_TLS_LE_32
)
3964 relocation
= elf_i386_tpoff (info
, relocation
);
3966 relocation
= -elf_i386_tpoff (info
, relocation
);
3973 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3974 because such sections are not SEC_ALLOC and thus ld.so will
3975 not process them. */
3976 if (unresolved_reloc
3977 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3980 (*_bfd_error_handler
)
3981 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3984 (long) rel
->r_offset
,
3986 h
->root
.root
.string
);
3991 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3992 contents
, rel
->r_offset
,
3995 if (r
!= bfd_reloc_ok
)
4000 name
= h
->root
.root
.string
;
4003 name
= bfd_elf_string_from_elf_section (input_bfd
,
4004 symtab_hdr
->sh_link
,
4009 name
= bfd_section_name (input_bfd
, sec
);
4012 if (r
== bfd_reloc_overflow
)
4014 if (! ((*info
->callbacks
->reloc_overflow
)
4015 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4016 (bfd_vma
) 0, input_bfd
, input_section
,
4022 (*_bfd_error_handler
)
4023 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4024 input_bfd
, input_section
,
4025 (long) rel
->r_offset
, name
, (int) r
);
4034 /* Finish up dynamic symbol handling. We set the contents of various
4035 dynamic sections here. */
4038 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
4039 struct bfd_link_info
*info
,
4040 struct elf_link_hash_entry
*h
,
4041 Elf_Internal_Sym
*sym
)
4043 struct elf_i386_link_hash_table
*htab
;
4045 htab
= elf_i386_hash_table (info
);
4047 if (h
->plt
.offset
!= (bfd_vma
) -1)
4051 Elf_Internal_Rela rel
;
4053 asection
*plt
, *gotplt
, *relplt
;
4055 /* When building a static executable, use .iplt, .igot.plt and
4056 .rel.iplt sections for STT_GNU_IFUNC symbols. */
4057 if (htab
->splt
!= NULL
)
4060 gotplt
= htab
->sgotplt
;
4061 relplt
= htab
->srelplt
;
4066 gotplt
= htab
->igotplt
;
4067 relplt
= htab
->irelplt
;
4070 /* This symbol has an entry in the procedure linkage table. Set
4073 if ((h
->dynindx
== -1
4074 && !((h
->forced_local
|| info
->executable
)
4076 && h
->type
== STT_GNU_IFUNC
))
4082 /* Get the index in the procedure linkage table which
4083 corresponds to this symbol. This is the index of this symbol
4084 in all the symbols for which we are making plt entries. The
4085 first entry in the procedure linkage table is reserved.
4087 Get the offset into the .got table of the entry that
4088 corresponds to this function. Each .got entry is 4 bytes.
4089 The first three are reserved.
4091 For static executables, we don't reserve anything. */
4093 if (plt
== htab
->splt
)
4095 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
4096 got_offset
= (plt_index
+ 3) * 4;
4100 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
4101 got_offset
= plt_index
* 4;
4104 /* Fill in the entry in the procedure linkage table. */
4107 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
4109 bfd_put_32 (output_bfd
,
4110 (gotplt
->output_section
->vma
4111 + gotplt
->output_offset
4113 plt
->contents
+ h
->plt
.offset
+ 2);
4115 if (htab
->is_vxworks
)
4117 int s
, k
, reloc_index
;
4119 /* Create the R_386_32 relocation referencing the GOT
4120 for this PLT entry. */
4122 /* S: Current slot number (zero-based). */
4123 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
4124 /* K: Number of relocations for PLTResolve. */
4126 k
= PLTRESOLVE_RELOCS_SHLIB
;
4128 k
= PLTRESOLVE_RELOCS
;
4129 /* Skip the PLTresolve relocations, and the relocations for
4130 the other PLT slots. */
4131 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
4132 loc
= (htab
->srelplt2
->contents
+ reloc_index
4133 * sizeof (Elf32_External_Rel
));
4135 rel
.r_offset
= (htab
->splt
->output_section
->vma
4136 + htab
->splt
->output_offset
4137 + h
->plt
.offset
+ 2),
4138 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4139 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4141 /* Create the R_386_32 relocation referencing the beginning of
4142 the PLT for this GOT entry. */
4143 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
4144 + htab
->sgotplt
->output_offset
4146 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4147 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4148 loc
+ sizeof (Elf32_External_Rel
));
4153 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
4155 bfd_put_32 (output_bfd
, got_offset
,
4156 plt
->contents
+ h
->plt
.offset
+ 2);
4159 /* Don't fill PLT entry for static executables. */
4160 if (plt
== htab
->splt
)
4162 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
4163 plt
->contents
+ h
->plt
.offset
+ 7);
4164 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
4165 plt
->contents
+ h
->plt
.offset
+ 12);
4168 /* Fill in the entry in the global offset table. */
4169 bfd_put_32 (output_bfd
,
4170 (plt
->output_section
->vma
4171 + plt
->output_offset
4174 gotplt
->contents
+ got_offset
);
4176 /* Fill in the entry in the .rel.plt section. */
4177 rel
.r_offset
= (gotplt
->output_section
->vma
4178 + gotplt
->output_offset
4180 if (h
->dynindx
== -1
4181 || ((info
->executable
4182 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4184 && h
->type
== STT_GNU_IFUNC
))
4186 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4187 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4188 in the .got.plt section. */
4189 bfd_put_32 (output_bfd
,
4190 (h
->root
.u
.def
.value
4191 + h
->root
.u
.def
.section
->output_section
->vma
4192 + h
->root
.u
.def
.section
->output_offset
),
4193 gotplt
->contents
+ got_offset
);
4194 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4197 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
4198 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
4199 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4201 if (!h
->def_regular
)
4203 /* Mark the symbol as undefined, rather than as defined in
4204 the .plt section. Leave the value if there were any
4205 relocations where pointer equality matters (this is a clue
4206 for the dynamic linker, to make function pointer
4207 comparisons work between an application and shared
4208 library), otherwise set it to zero. If a function is only
4209 called from a binary, there is no need to slow down
4210 shared libraries because of that. */
4211 sym
->st_shndx
= SHN_UNDEF
;
4212 if (!h
->pointer_equality_needed
)
4217 if (h
->got
.offset
!= (bfd_vma
) -1
4218 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
4219 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
4221 Elf_Internal_Rela rel
;
4224 /* This symbol has an entry in the global offset table. Set it
4227 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
4230 rel
.r_offset
= (htab
->sgot
->output_section
->vma
4231 + htab
->sgot
->output_offset
4232 + (h
->got
.offset
& ~(bfd_vma
) 1));
4234 /* If this is a static link, or it is a -Bsymbolic link and the
4235 symbol is defined locally or was forced to be local because
4236 of a version file, we just want to emit a RELATIVE reloc.
4237 The entry in the global offset table will already have been
4238 initialized in the relocate_section function. */
4240 && h
->type
== STT_GNU_IFUNC
)
4244 /* Generate R_386_GLOB_DAT. */
4249 if (!h
->pointer_equality_needed
)
4252 /* For non-shared object, we can't use .got.plt, which
4253 contains the real function addres if we need pointer
4254 equality. We load the GOT entry with the PLT entry. */
4255 asection
*plt
= htab
->splt
? htab
->splt
: htab
->iplt
;
4256 bfd_put_32 (output_bfd
,
4257 (plt
->output_section
->vma
4258 + plt
->output_offset
+ h
->plt
.offset
),
4259 htab
->sgot
->contents
+ h
->got
.offset
);
4263 else if (info
->shared
4264 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4266 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4267 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4271 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4273 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4274 htab
->sgot
->contents
+ h
->got
.offset
);
4275 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
4278 loc
= htab
->srelgot
->contents
;
4279 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4280 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4285 Elf_Internal_Rela rel
;
4288 /* This symbol needs a copy reloc. Set it up. */
4290 if (h
->dynindx
== -1
4291 || (h
->root
.type
!= bfd_link_hash_defined
4292 && h
->root
.type
!= bfd_link_hash_defweak
)
4293 || htab
->srelbss
== NULL
)
4296 rel
.r_offset
= (h
->root
.u
.def
.value
4297 + h
->root
.u
.def
.section
->output_section
->vma
4298 + h
->root
.u
.def
.section
->output_offset
);
4299 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
4300 loc
= htab
->srelbss
->contents
;
4301 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4302 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4305 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
4306 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
4307 is relative to the ".got" section. */
4308 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4309 || (!htab
->is_vxworks
&& h
== htab
->elf
.hgot
))
4310 sym
->st_shndx
= SHN_ABS
;
4315 /* Used to decide how to sort relocs in an optimal manner for the
4316 dynamic linker, before writing them out. */
4318 static enum elf_reloc_type_class
4319 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
4321 switch (ELF32_R_TYPE (rela
->r_info
))
4323 case R_386_RELATIVE
:
4324 return reloc_class_relative
;
4325 case R_386_JUMP_SLOT
:
4326 return reloc_class_plt
;
4328 return reloc_class_copy
;
4330 return reloc_class_normal
;
4334 /* Finish up the dynamic sections. */
4337 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
4338 struct bfd_link_info
*info
)
4340 struct elf_i386_link_hash_table
*htab
;
4344 htab
= elf_i386_hash_table (info
);
4345 dynobj
= htab
->elf
.dynobj
;
4346 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4348 if (htab
->elf
.dynamic_sections_created
)
4350 Elf32_External_Dyn
*dyncon
, *dynconend
;
4352 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
4355 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4356 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4357 for (; dyncon
< dynconend
; dyncon
++)
4359 Elf_Internal_Dyn dyn
;
4362 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4367 if (htab
->is_vxworks
4368 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
4374 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4379 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4384 dyn
.d_un
.d_val
= s
->size
;
4388 /* My reading of the SVR4 ABI indicates that the
4389 procedure linkage table relocs (DT_JMPREL) should be
4390 included in the overall relocs (DT_REL). This is
4391 what Solaris does. However, UnixWare can not handle
4392 that case. Therefore, we override the DT_RELSZ entry
4393 here to make it not include the JMPREL relocs. */
4397 dyn
.d_un
.d_val
-= s
->size
;
4401 /* We may not be using the standard ELF linker script.
4402 If .rel.plt is the first .rel section, we adjust
4403 DT_REL to not include it. */
4407 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
4409 dyn
.d_un
.d_ptr
+= s
->size
;
4413 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4416 /* Fill in the first entry in the procedure linkage table. */
4417 if (htab
->splt
&& htab
->splt
->size
> 0)
4421 memcpy (htab
->splt
->contents
, elf_i386_pic_plt0_entry
,
4422 sizeof (elf_i386_pic_plt0_entry
));
4423 memset (htab
->splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
4424 htab
->plt0_pad_byte
,
4425 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
4429 memcpy (htab
->splt
->contents
, elf_i386_plt0_entry
,
4430 sizeof(elf_i386_plt0_entry
));
4431 memset (htab
->splt
->contents
+ sizeof (elf_i386_plt0_entry
),
4432 htab
->plt0_pad_byte
,
4433 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
4434 bfd_put_32 (output_bfd
,
4435 (htab
->sgotplt
->output_section
->vma
4436 + htab
->sgotplt
->output_offset
4438 htab
->splt
->contents
+ 2);
4439 bfd_put_32 (output_bfd
,
4440 (htab
->sgotplt
->output_section
->vma
4441 + htab
->sgotplt
->output_offset
4443 htab
->splt
->contents
+ 8);
4445 if (htab
->is_vxworks
)
4447 Elf_Internal_Rela rel
;
4449 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4450 On IA32 we use REL relocations so the addend goes in
4451 the PLT directly. */
4452 rel
.r_offset
= (htab
->splt
->output_section
->vma
4453 + htab
->splt
->output_offset
4455 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4456 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4457 htab
->srelplt2
->contents
);
4458 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
4459 rel
.r_offset
= (htab
->splt
->output_section
->vma
4460 + htab
->splt
->output_offset
4462 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4463 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4464 htab
->srelplt2
->contents
+
4465 sizeof (Elf32_External_Rel
));
4469 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4470 really seem like the right value. */
4471 elf_section_data (htab
->splt
->output_section
)
4472 ->this_hdr
.sh_entsize
= 4;
4474 /* Correct the .rel.plt.unloaded relocations. */
4475 if (htab
->is_vxworks
&& !info
->shared
)
4477 int num_plts
= (htab
->splt
->size
/ PLT_ENTRY_SIZE
) - 1;
4480 p
= htab
->srelplt2
->contents
;
4482 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
4484 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
4486 for (; num_plts
; num_plts
--)
4488 Elf_Internal_Rela rel
;
4489 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4490 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4491 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4492 p
+= sizeof (Elf32_External_Rel
);
4494 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4495 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4496 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4497 p
+= sizeof (Elf32_External_Rel
);
4505 /* Fill in the first three entries in the global offset table. */
4506 if (htab
->sgotplt
->size
> 0)
4508 bfd_put_32 (output_bfd
,
4510 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
4511 htab
->sgotplt
->contents
);
4512 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 4);
4513 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 8);
4516 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
4519 if (htab
->sgot
&& htab
->sgot
->size
> 0)
4520 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4525 /* Return address for Ith PLT stub in section PLT, for relocation REL
4526 or (bfd_vma) -1 if it should not be included. */
4529 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
4530 const arelent
*rel ATTRIBUTE_UNUSED
)
4532 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4535 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4538 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
4540 if (h
->plt
.offset
!= (bfd_vma
) -1
4542 && !h
->pointer_equality_needed
)
4545 return _bfd_elf_hash_symbol (h
);
4548 /* Hook called by the linker routine which adds symbols from an object
4552 elf_i386_add_symbol_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
4553 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4554 Elf_Internal_Sym
* sym
,
4555 const char ** namep ATTRIBUTE_UNUSED
,
4556 flagword
* flagsp ATTRIBUTE_UNUSED
,
4557 asection
** secp ATTRIBUTE_UNUSED
,
4558 bfd_vma
* valp ATTRIBUTE_UNUSED
)
4560 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4561 elf_tdata (info
->output_bfd
)->has_ifunc_symbols
= TRUE
;
4566 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4567 #define TARGET_LITTLE_NAME "elf32-i386"
4568 #define ELF_ARCH bfd_arch_i386
4569 #define ELF_MACHINE_CODE EM_386
4570 #define ELF_MAXPAGESIZE 0x1000
4572 #define elf_backend_can_gc_sections 1
4573 #define elf_backend_can_refcount 1
4574 #define elf_backend_want_got_plt 1
4575 #define elf_backend_plt_readonly 1
4576 #define elf_backend_want_plt_sym 0
4577 #define elf_backend_got_header_size 12
4579 /* Support RELA for objdump of prelink objects. */
4580 #define elf_info_to_howto elf_i386_info_to_howto_rel
4581 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4583 #define bfd_elf32_mkobject elf_i386_mkobject
4585 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4586 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
4587 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
4588 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
4590 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
4591 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4592 #define elf_backend_check_relocs elf_i386_check_relocs
4593 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
4594 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
4595 #define elf_backend_fake_sections elf_i386_fake_sections
4596 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4597 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4598 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4599 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
4600 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
4601 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
4602 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
4603 #define elf_backend_relocate_section elf_i386_relocate_section
4604 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
4605 #define elf_backend_always_size_sections elf_i386_always_size_sections
4606 #define elf_backend_omit_section_dynsym \
4607 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4608 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
4609 #define elf_backend_hash_symbol elf_i386_hash_symbol
4610 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
4611 #undef elf_backend_post_process_headers
4612 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4614 #include "elf32-target.h"
4616 /* FreeBSD support. */
4618 #undef TARGET_LITTLE_SYM
4619 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4620 #undef TARGET_LITTLE_NAME
4621 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
4623 #define ELF_OSABI ELFOSABI_FREEBSD
4625 /* The kernel recognizes executables as valid only if they carry a
4626 "FreeBSD" label in the ELF header. So we put this label on all
4627 executables and (for simplicity) also all other object files. */
4630 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
4632 _bfd_elf_set_osabi (abfd
, info
);
4634 #ifdef OLD_FREEBSD_ABI_LABEL
4635 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4636 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
4640 #undef elf_backend_post_process_headers
4641 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
4643 #define elf32_bed elf32_i386_fbsd_bed
4645 #undef elf_backend_add_symbol_hook
4647 #include "elf32-target.h"
4649 /* VxWorks support. */
4651 #undef TARGET_LITTLE_SYM
4652 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4653 #undef TARGET_LITTLE_NAME
4654 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
4657 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
4659 static struct bfd_link_hash_table
*
4660 elf_i386_vxworks_link_hash_table_create (bfd
*abfd
)
4662 struct bfd_link_hash_table
*ret
;
4663 struct elf_i386_link_hash_table
*htab
;
4665 ret
= elf_i386_link_hash_table_create (abfd
);
4668 htab
= (struct elf_i386_link_hash_table
*) ret
;
4669 htab
->is_vxworks
= 1;
4670 htab
->plt0_pad_byte
= 0x90;
4677 #undef elf_backend_relocs_compatible
4678 #undef elf_backend_post_process_headers
4679 #undef bfd_elf32_bfd_link_hash_table_create
4680 #define bfd_elf32_bfd_link_hash_table_create \
4681 elf_i386_vxworks_link_hash_table_create
4682 #undef elf_backend_add_symbol_hook
4683 #define elf_backend_add_symbol_hook \
4684 elf_vxworks_add_symbol_hook
4685 #undef elf_backend_link_output_symbol_hook
4686 #define elf_backend_link_output_symbol_hook \
4687 elf_vxworks_link_output_symbol_hook
4688 #undef elf_backend_emit_relocs
4689 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4690 #undef elf_backend_final_write_processing
4691 #define elf_backend_final_write_processing \
4692 elf_vxworks_final_write_processing
4694 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4696 #undef elf_backend_want_plt_sym
4697 #define elf_backend_want_plt_sym 1
4700 #define elf32_bed elf32_i386_vxworks_bed
4702 #include "elf32-target.h"