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. */
683 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
686 /* True if the target system is VxWorks. */
689 /* Value used to fill the last word of the first plt entry. */
690 bfd_byte plt0_pad_byte
;
692 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
693 bfd_vma next_tls_desc_index
;
696 bfd_signed_vma refcount
;
700 /* The amount of space used by the reserved portion of the sgotplt
701 section, plus whatever space is used by the jump slots. */
702 bfd_vma sgotplt_jump_table_size
;
704 /* Small local sym to section mapping cache. */
705 struct sym_sec_cache sym_sec
;
707 /* _TLS_MODULE_BASE_ symbol. */
708 struct bfd_link_hash_entry
*tls_module_base
;
711 /* Get the i386 ELF linker hash table from a link_info structure. */
713 #define elf_i386_hash_table(p) \
714 ((struct elf_i386_link_hash_table *) ((p)->hash))
716 #define elf_i386_compute_jump_table_size(htab) \
717 ((htab)->next_tls_desc_index * 4)
719 /* Create an entry in an i386 ELF linker hash table. */
721 static struct bfd_hash_entry
*
722 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
723 struct bfd_hash_table
*table
,
726 /* Allocate the structure if it has not already been allocated by a
730 entry
= bfd_hash_allocate (table
,
731 sizeof (struct elf_i386_link_hash_entry
));
736 /* Call the allocation method of the superclass. */
737 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
740 struct elf_i386_link_hash_entry
*eh
;
742 eh
= (struct elf_i386_link_hash_entry
*) entry
;
743 eh
->dyn_relocs
= NULL
;
744 eh
->tls_type
= GOT_UNKNOWN
;
745 eh
->tlsdesc_got
= (bfd_vma
) -1;
751 /* Create an i386 ELF linker hash table. */
753 static struct bfd_link_hash_table
*
754 elf_i386_link_hash_table_create (bfd
*abfd
)
756 struct elf_i386_link_hash_table
*ret
;
757 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
759 ret
= bfd_malloc (amt
);
763 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
764 elf_i386_link_hash_newfunc
,
765 sizeof (struct elf_i386_link_hash_entry
)))
781 ret
->irelifunc
= NULL
;
782 ret
->tls_ldm_got
.refcount
= 0;
783 ret
->next_tls_desc_index
= 0;
784 ret
->sgotplt_jump_table_size
= 0;
785 ret
->sym_sec
.abfd
= NULL
;
787 ret
->srelplt2
= NULL
;
788 ret
->plt0_pad_byte
= 0;
789 ret
->tls_module_base
= NULL
;
791 return &ret
->elf
.root
;
794 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
795 shortcuts to them in our hash table. */
798 elf_i386_create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
800 struct elf_i386_link_hash_table
*htab
;
802 if (! _bfd_elf_create_got_section (dynobj
, info
))
805 htab
= elf_i386_hash_table (info
);
806 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
807 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
808 if (!htab
->sgot
|| !htab
->sgotplt
)
811 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rel.got",
812 (SEC_ALLOC
| SEC_LOAD
817 if (htab
->srelgot
== NULL
818 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
823 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
824 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
828 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
830 struct elf_i386_link_hash_table
*htab
;
832 htab
= elf_i386_hash_table (info
);
833 if (!htab
->sgot
&& !elf_i386_create_got_section (dynobj
, info
))
836 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
839 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
840 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
841 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
843 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
845 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
846 || (!info
->shared
&& !htab
->srelbss
))
850 && !elf_vxworks_create_dynamic_sections (dynobj
, info
, &htab
->srelplt2
))
856 /* Copy the extra info we tack onto an elf_link_hash_entry. */
859 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
860 struct elf_link_hash_entry
*dir
,
861 struct elf_link_hash_entry
*ind
)
863 struct elf_i386_link_hash_entry
*edir
, *eind
;
865 edir
= (struct elf_i386_link_hash_entry
*) dir
;
866 eind
= (struct elf_i386_link_hash_entry
*) ind
;
868 if (eind
->dyn_relocs
!= NULL
)
870 if (edir
->dyn_relocs
!= NULL
)
872 struct elf_i386_dyn_relocs
**pp
;
873 struct elf_i386_dyn_relocs
*p
;
875 /* Add reloc counts against the indirect sym to the direct sym
876 list. Merge any entries against the same section. */
877 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
879 struct elf_i386_dyn_relocs
*q
;
881 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
882 if (q
->sec
== p
->sec
)
884 q
->pc_count
+= p
->pc_count
;
885 q
->count
+= p
->count
;
892 *pp
= edir
->dyn_relocs
;
895 edir
->dyn_relocs
= eind
->dyn_relocs
;
896 eind
->dyn_relocs
= NULL
;
899 if (ind
->root
.type
== bfd_link_hash_indirect
900 && dir
->got
.refcount
<= 0)
902 edir
->tls_type
= eind
->tls_type
;
903 eind
->tls_type
= GOT_UNKNOWN
;
906 if (ELIMINATE_COPY_RELOCS
907 && ind
->root
.type
!= bfd_link_hash_indirect
908 && dir
->dynamic_adjusted
)
910 /* If called to transfer flags for a weakdef during processing
911 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
912 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
913 dir
->ref_dynamic
|= ind
->ref_dynamic
;
914 dir
->ref_regular
|= ind
->ref_regular
;
915 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
916 dir
->needs_plt
|= ind
->needs_plt
;
917 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
920 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
930 /* Return TRUE if the TLS access code sequence support transition
934 elf_i386_check_tls_transition (bfd
*abfd
, asection
*sec
,
936 Elf_Internal_Shdr
*symtab_hdr
,
937 struct elf_link_hash_entry
**sym_hashes
,
939 const Elf_Internal_Rela
*rel
,
940 const Elf_Internal_Rela
*relend
)
942 unsigned int val
, type
;
943 unsigned long r_symndx
;
944 struct elf_link_hash_entry
*h
;
947 /* Get the section contents. */
948 if (contents
== NULL
)
950 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
951 contents
= elf_section_data (sec
)->this_hdr
.contents
;
954 /* FIXME: How to better handle error condition? */
955 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
958 /* Cache the section contents for elf_link_input_bfd. */
959 elf_section_data (sec
)->this_hdr
.contents
= contents
;
963 offset
= rel
->r_offset
;
968 if (offset
< 2 || (rel
+ 1) >= relend
)
971 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
972 if (r_type
== R_386_TLS_GD
)
974 /* Check transition from GD access model. Only
975 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
976 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
977 can transit to different access model. */
978 if ((offset
+ 10) > sec
->size
||
979 (type
!= 0x8d && type
!= 0x04))
982 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
985 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
989 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
992 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
997 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
998 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1001 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1007 /* Check transition from LD access model. Only
1008 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1009 can transit to different access model. */
1010 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1013 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1014 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1018 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1021 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1022 if (r_symndx
< symtab_hdr
->sh_info
)
1025 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1026 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1027 may be versioned. */
1029 && h
->root
.root
.string
!= NULL
1030 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1031 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1032 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1036 /* Check transition from IE access model:
1037 movl foo@indntpoff(%rip), %eax
1038 movl foo@indntpoff(%rip), %reg
1039 addl foo@indntpoff(%rip), %reg
1042 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1045 /* Check "movl foo@tpoff(%rip), %eax" first. */
1046 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1053 /* Check movl|addl foo@tpoff(%rip), %reg. */
1054 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1055 return ((type
== 0x8b || type
== 0x03)
1056 && (val
& 0xc7) == 0x05);
1058 case R_386_TLS_GOTIE
:
1059 case R_386_TLS_IE_32
:
1060 /* Check transition from {IE_32,GOTIE} access model:
1061 subl foo@{tpoff,gontoff}(%reg1), %reg2
1062 movl foo@{tpoff,gontoff}(%reg1), %reg2
1063 addl foo@{tpoff,gontoff}(%reg1), %reg2
1066 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1069 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1070 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1073 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1074 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1076 case R_386_TLS_GOTDESC
:
1077 /* Check transition from GDesc access model:
1078 leal x@tlsdesc(%ebx), %eax
1080 Make sure it's a leal adding ebx to a 32-bit offset
1081 into any register, although it's probably almost always
1084 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1087 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1090 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1091 return (val
& 0xc7) == 0x83;
1093 case R_386_TLS_DESC_CALL
:
1094 /* Check transition from GDesc access model:
1095 call *x@tlsdesc(%rax)
1097 if (offset
+ 2 <= sec
->size
)
1099 /* Make sure that it's a call *x@tlsdesc(%rax). */
1100 static i386_opcode16 call
= { { 0xff, 0x10 } };
1101 return bfd_get_16 (abfd
, contents
+ offset
) == call
.i
;
1111 /* Return TRUE if the TLS access transition is OK or no transition
1112 will be performed. Update R_TYPE if there is a transition. */
1115 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1116 asection
*sec
, bfd_byte
*contents
,
1117 Elf_Internal_Shdr
*symtab_hdr
,
1118 struct elf_link_hash_entry
**sym_hashes
,
1119 unsigned int *r_type
, int tls_type
,
1120 const Elf_Internal_Rela
*rel
,
1121 const Elf_Internal_Rela
*relend
,
1122 struct elf_link_hash_entry
*h
)
1124 unsigned int from_type
= *r_type
;
1125 unsigned int to_type
= from_type
;
1126 bfd_boolean check
= TRUE
;
1131 case R_386_TLS_GOTDESC
:
1132 case R_386_TLS_DESC_CALL
:
1133 case R_386_TLS_IE_32
:
1135 case R_386_TLS_GOTIE
:
1139 to_type
= R_386_TLS_LE_32
;
1140 else if (from_type
!= R_386_TLS_IE
1141 && from_type
!= R_386_TLS_GOTIE
)
1142 to_type
= R_386_TLS_IE_32
;
1145 /* When we are called from elf_i386_relocate_section, CONTENTS
1146 isn't NULL and there may be additional transitions based on
1148 if (contents
!= NULL
)
1150 unsigned int new_to_type
= to_type
;
1155 && (tls_type
& GOT_TLS_IE
))
1156 new_to_type
= R_386_TLS_LE_32
;
1158 if (to_type
== R_386_TLS_GD
1159 || to_type
== R_386_TLS_GOTDESC
1160 || to_type
== R_386_TLS_DESC_CALL
)
1162 if (tls_type
== GOT_TLS_IE_POS
)
1163 new_to_type
= R_386_TLS_GOTIE
;
1164 else if (tls_type
& GOT_TLS_IE
)
1165 new_to_type
= R_386_TLS_IE_32
;
1168 /* We checked the transition before when we were called from
1169 elf_i386_check_relocs. We only want to check the new
1170 transition which hasn't been checked before. */
1171 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1172 to_type
= new_to_type
;
1179 to_type
= R_386_TLS_LE_32
;
1186 /* Return TRUE if there is no transition. */
1187 if (from_type
== to_type
)
1190 /* Check if the transition can be performed. */
1192 && ! elf_i386_check_tls_transition (abfd
, sec
, contents
,
1193 symtab_hdr
, sym_hashes
,
1194 from_type
, rel
, relend
))
1196 reloc_howto_type
*from
, *to
;
1198 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1199 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1201 (*_bfd_error_handler
)
1202 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1203 "in section `%A' failed"),
1204 abfd
, sec
, from
->name
, to
->name
,
1205 h
? h
->root
.root
.string
: "a local symbol",
1206 (unsigned long) rel
->r_offset
);
1207 bfd_set_error (bfd_error_bad_value
);
1215 /* Look through the relocs for a section during the first phase, and
1216 calculate needed space in the global offset table, procedure linkage
1217 table, and dynamic reloc sections. */
1220 elf_i386_check_relocs (bfd
*abfd
,
1221 struct bfd_link_info
*info
,
1223 const Elf_Internal_Rela
*relocs
)
1225 struct elf_i386_link_hash_table
*htab
;
1226 Elf_Internal_Shdr
*symtab_hdr
;
1227 struct elf_link_hash_entry
**sym_hashes
;
1228 const Elf_Internal_Rela
*rel
;
1229 const Elf_Internal_Rela
*rel_end
;
1232 if (info
->relocatable
)
1235 BFD_ASSERT (is_i386_elf (abfd
));
1237 htab
= elf_i386_hash_table (info
);
1238 symtab_hdr
= &elf_symtab_hdr (abfd
);
1239 sym_hashes
= elf_sym_hashes (abfd
);
1243 rel_end
= relocs
+ sec
->reloc_count
;
1244 for (rel
= relocs
; rel
< rel_end
; rel
++)
1246 unsigned int r_type
;
1247 unsigned long r_symndx
;
1248 struct elf_link_hash_entry
*h
;
1250 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1251 r_type
= ELF32_R_TYPE (rel
->r_info
);
1253 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1255 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1261 if (r_symndx
< symtab_hdr
->sh_info
)
1265 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1266 while (h
->root
.type
== bfd_link_hash_indirect
1267 || h
->root
.type
== bfd_link_hash_warning
)
1268 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1270 /* Create the ifunc sections for static executables. If we
1271 never see an indirect function symbol nor we are building
1272 a static executable, those sections will be empty and
1273 won't appear in output. */
1284 if (htab
->irelifunc
== NULL
&& htab
->iplt
== NULL
)
1286 if (!_bfd_elf_create_ifunc_sections (abfd
, info
))
1291 htab
->irelifunc
= bfd_get_section_by_name (abfd
,
1293 if (!htab
->irelifunc
)
1298 htab
->iplt
= bfd_get_section_by_name (abfd
, ".iplt");
1299 htab
->irelplt
= bfd_get_section_by_name (abfd
,
1301 htab
->igotplt
= bfd_get_section_by_name (abfd
,
1312 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1313 it here if it is defined in a non-shared object. */
1314 if (h
->type
== STT_GNU_IFUNC
1317 /* It is referenced by a non-shared object. */
1320 /* STT_GNU_IFUNC symbol must go through PLT. */
1321 h
->plt
.refcount
+= 1;
1323 /* STT_GNU_IFUNC needs dynamic sections. */
1324 if (htab
->elf
.dynobj
== NULL
)
1325 htab
->elf
.dynobj
= abfd
;
1330 (*_bfd_error_handler
)
1331 (_("%B: relocation %s against STT_GNU_IFUNC "
1332 "symbol `%s' isn't handled by %s"), abfd
,
1333 elf_howto_table
[r_type
].name
,
1334 h
->root
.root
.string
, __FUNCTION__
);
1335 bfd_set_error (bfd_error_bad_value
);
1340 h
->pointer_equality_needed
= 1;
1343 struct elf_i386_dyn_relocs
*p
;
1344 struct elf_i386_dyn_relocs
**head
;
1346 /* We must copy these reloc types into the
1347 output file. Create a reloc section in
1348 dynobj and make room for this reloc. */
1351 if (htab
->elf
.dynobj
== NULL
)
1352 htab
->elf
.dynobj
= abfd
;
1354 sreloc
= _bfd_elf_make_dynamic_reloc_section
1355 (sec
, htab
->elf
.dynobj
, 2, abfd
, FALSE
);
1361 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1363 if (p
== NULL
|| p
->sec
!= sec
)
1365 bfd_size_type amt
= sizeof *p
;
1366 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1388 h
->got
.refcount
+= 1;
1389 if (htab
->sgot
== NULL
1390 && !elf_i386_create_got_section (htab
->elf
.dynobj
,
1400 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1401 symtab_hdr
, sym_hashes
,
1402 &r_type
, GOT_UNKNOWN
,
1409 htab
->tls_ldm_got
.refcount
+= 1;
1413 /* This symbol requires a procedure linkage table entry. We
1414 actually build the entry in adjust_dynamic_symbol,
1415 because this might be a case of linking PIC code which is
1416 never referenced by a dynamic object, in which case we
1417 don't need to generate a procedure linkage table entry
1420 /* If this is a local symbol, we resolve it directly without
1421 creating a procedure linkage table entry. */
1426 h
->plt
.refcount
+= 1;
1429 case R_386_TLS_IE_32
:
1431 case R_386_TLS_GOTIE
:
1433 info
->flags
|= DF_STATIC_TLS
;
1438 case R_386_TLS_GOTDESC
:
1439 case R_386_TLS_DESC_CALL
:
1440 /* This symbol requires a global offset table entry. */
1442 int tls_type
, old_tls_type
;
1447 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1448 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1449 case R_386_TLS_GOTDESC
:
1450 case R_386_TLS_DESC_CALL
:
1451 tls_type
= GOT_TLS_GDESC
; break;
1452 case R_386_TLS_IE_32
:
1453 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1454 tls_type
= GOT_TLS_IE_NEG
;
1456 /* If this is a GD->IE transition, we may use either of
1457 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1458 tls_type
= GOT_TLS_IE
;
1461 case R_386_TLS_GOTIE
:
1462 tls_type
= GOT_TLS_IE_POS
; break;
1467 h
->got
.refcount
+= 1;
1468 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1472 bfd_signed_vma
*local_got_refcounts
;
1474 /* This is a global offset table entry for a local symbol. */
1475 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1476 if (local_got_refcounts
== NULL
)
1480 size
= symtab_hdr
->sh_info
;
1481 size
*= (sizeof (bfd_signed_vma
)
1482 + sizeof (bfd_vma
) + sizeof(char));
1483 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1484 if (local_got_refcounts
== NULL
)
1486 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1487 elf_i386_local_tlsdesc_gotent (abfd
)
1488 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1489 elf_i386_local_got_tls_type (abfd
)
1490 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1492 local_got_refcounts
[r_symndx
] += 1;
1493 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1496 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1497 tls_type
|= old_tls_type
;
1498 /* If a TLS symbol is accessed using IE at least once,
1499 there is no point to use dynamic model for it. */
1500 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1501 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1502 || (tls_type
& GOT_TLS_IE
) == 0))
1504 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1505 tls_type
= old_tls_type
;
1506 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1507 && GOT_TLS_GD_ANY_P (tls_type
))
1508 tls_type
|= old_tls_type
;
1511 (*_bfd_error_handler
)
1512 (_("%B: `%s' accessed both as normal and "
1513 "thread local symbol"),
1515 h
? h
->root
.root
.string
: "<local>");
1520 if (old_tls_type
!= tls_type
)
1523 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1525 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1533 if (htab
->sgot
== NULL
)
1535 if (htab
->elf
.dynobj
== NULL
)
1536 htab
->elf
.dynobj
= abfd
;
1537 if (!elf_i386_create_got_section (htab
->elf
.dynobj
, info
))
1540 if (r_type
!= R_386_TLS_IE
)
1544 case R_386_TLS_LE_32
:
1548 info
->flags
|= DF_STATIC_TLS
;
1553 if (h
!= NULL
&& info
->executable
)
1555 /* If this reloc is in a read-only section, we might
1556 need a copy reloc. We can't check reliably at this
1557 stage whether the section is read-only, as input
1558 sections have not yet been mapped to output sections.
1559 Tentatively set the flag for now, and correct in
1560 adjust_dynamic_symbol. */
1563 /* We may need a .plt entry if the function this reloc
1564 refers to is in a shared lib. */
1565 h
->plt
.refcount
+= 1;
1566 if (r_type
!= R_386_PC32
)
1567 h
->pointer_equality_needed
= 1;
1570 /* If we are creating a shared library, and this is a reloc
1571 against a global symbol, or a non PC relative reloc
1572 against a local symbol, then we need to copy the reloc
1573 into the shared library. However, if we are linking with
1574 -Bsymbolic, we do not need to copy a reloc against a
1575 global symbol which is defined in an object we are
1576 including in the link (i.e., DEF_REGULAR is set). At
1577 this point we have not seen all the input files, so it is
1578 possible that DEF_REGULAR is not set now but will be set
1579 later (it is never cleared). In case of a weak definition,
1580 DEF_REGULAR may be cleared later by a strong definition in
1581 a shared library. We account for that possibility below by
1582 storing information in the relocs_copied field of the hash
1583 table entry. A similar situation occurs when creating
1584 shared libraries and symbol visibility changes render the
1587 If on the other hand, we are creating an executable, we
1588 may need to keep relocations for symbols satisfied by a
1589 dynamic library if we manage to avoid copy relocs for the
1592 && (sec
->flags
& SEC_ALLOC
) != 0
1593 && (r_type
!= R_386_PC32
1595 && (! SYMBOLIC_BIND (info
, h
)
1596 || h
->root
.type
== bfd_link_hash_defweak
1597 || !h
->def_regular
))))
1598 || (ELIMINATE_COPY_RELOCS
1600 && (sec
->flags
& SEC_ALLOC
) != 0
1602 && (h
->root
.type
== bfd_link_hash_defweak
1603 || !h
->def_regular
)))
1605 struct elf_i386_dyn_relocs
*p
;
1606 struct elf_i386_dyn_relocs
**head
;
1608 /* We must copy these reloc types into the output file.
1609 Create a reloc section in dynobj and make room for
1613 if (htab
->elf
.dynobj
== NULL
)
1614 htab
->elf
.dynobj
= abfd
;
1616 sreloc
= _bfd_elf_make_dynamic_reloc_section
1617 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1623 /* If this is a global symbol, we count the number of
1624 relocations we need for this symbol. */
1627 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1632 /* Track dynamic relocs needed for local syms too.
1633 We really need local syms available to do this
1637 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1642 vpp
= &elf_section_data (s
)->local_dynrel
;
1643 head
= (struct elf_i386_dyn_relocs
**)vpp
;
1647 if (p
== NULL
|| p
->sec
!= sec
)
1649 bfd_size_type amt
= sizeof *p
;
1650 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1661 if (r_type
== R_386_PC32
)
1666 /* This relocation describes the C++ object vtable hierarchy.
1667 Reconstruct it for later use during GC. */
1668 case R_386_GNU_VTINHERIT
:
1669 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1673 /* This relocation describes which C++ vtable entries are actually
1674 used. Record for later use during GC. */
1675 case R_386_GNU_VTENTRY
:
1676 BFD_ASSERT (h
!= NULL
);
1678 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1690 /* Return the section that should be marked against GC for a given
1694 elf_i386_gc_mark_hook (asection
*sec
,
1695 struct bfd_link_info
*info
,
1696 Elf_Internal_Rela
*rel
,
1697 struct elf_link_hash_entry
*h
,
1698 Elf_Internal_Sym
*sym
)
1701 switch (ELF32_R_TYPE (rel
->r_info
))
1703 case R_386_GNU_VTINHERIT
:
1704 case R_386_GNU_VTENTRY
:
1708 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1711 /* Update the got entry reference counts for the section being removed. */
1714 elf_i386_gc_sweep_hook (bfd
*abfd
,
1715 struct bfd_link_info
*info
,
1717 const Elf_Internal_Rela
*relocs
)
1719 Elf_Internal_Shdr
*symtab_hdr
;
1720 struct elf_link_hash_entry
**sym_hashes
;
1721 bfd_signed_vma
*local_got_refcounts
;
1722 const Elf_Internal_Rela
*rel
, *relend
;
1724 if (info
->relocatable
)
1727 elf_section_data (sec
)->local_dynrel
= NULL
;
1729 symtab_hdr
= &elf_symtab_hdr (abfd
);
1730 sym_hashes
= elf_sym_hashes (abfd
);
1731 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1733 relend
= relocs
+ sec
->reloc_count
;
1734 for (rel
= relocs
; rel
< relend
; rel
++)
1736 unsigned long r_symndx
;
1737 unsigned int r_type
;
1738 struct elf_link_hash_entry
*h
= NULL
;
1740 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1741 if (r_symndx
>= symtab_hdr
->sh_info
)
1743 struct elf_i386_link_hash_entry
*eh
;
1744 struct elf_i386_dyn_relocs
**pp
;
1745 struct elf_i386_dyn_relocs
*p
;
1747 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1748 while (h
->root
.type
== bfd_link_hash_indirect
1749 || h
->root
.type
== bfd_link_hash_warning
)
1750 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1751 eh
= (struct elf_i386_link_hash_entry
*) h
;
1753 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1756 /* Everything must go for SEC. */
1762 r_type
= ELF32_R_TYPE (rel
->r_info
);
1763 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1764 symtab_hdr
, sym_hashes
,
1765 &r_type
, GOT_UNKNOWN
,
1772 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1773 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1777 case R_386_TLS_GOTDESC
:
1778 case R_386_TLS_DESC_CALL
:
1779 case R_386_TLS_IE_32
:
1781 case R_386_TLS_GOTIE
:
1785 if (h
->got
.refcount
> 0)
1786 h
->got
.refcount
-= 1;
1788 else if (local_got_refcounts
!= NULL
)
1790 if (local_got_refcounts
[r_symndx
] > 0)
1791 local_got_refcounts
[r_symndx
] -= 1;
1804 if (h
->plt
.refcount
> 0)
1805 h
->plt
.refcount
-= 1;
1817 /* Adjust a symbol defined by a dynamic object and referenced by a
1818 regular object. The current definition is in some section of the
1819 dynamic object, but we're not including those sections. We have to
1820 change the definition to something the rest of the link can
1824 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1825 struct elf_link_hash_entry
*h
)
1827 struct elf_i386_link_hash_table
*htab
;
1830 /* STT_GNU_IFUNC symbol must go through PLT. */
1831 if (h
->type
== STT_GNU_IFUNC
)
1833 if (h
->plt
.refcount
<= 0)
1835 h
->plt
.offset
= (bfd_vma
) -1;
1841 /* If this is a function, put it in the procedure linkage table. We
1842 will fill in the contents of the procedure linkage table later,
1843 when we know the address of the .got section. */
1844 if (h
->type
== STT_FUNC
1847 if (h
->plt
.refcount
<= 0
1848 || SYMBOL_CALLS_LOCAL (info
, h
)
1849 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1850 && h
->root
.type
== bfd_link_hash_undefweak
))
1852 /* This case can occur if we saw a PLT32 reloc in an input
1853 file, but the symbol was never referred to by a dynamic
1854 object, or if all references were garbage collected. In
1855 such a case, we don't actually need to build a procedure
1856 linkage table, and we can just do a PC32 reloc instead. */
1857 h
->plt
.offset
= (bfd_vma
) -1;
1864 /* It's possible that we incorrectly decided a .plt reloc was
1865 needed for an R_386_PC32 reloc to a non-function sym in
1866 check_relocs. We can't decide accurately between function and
1867 non-function syms in check-relocs; Objects loaded later in
1868 the link may change h->type. So fix it now. */
1869 h
->plt
.offset
= (bfd_vma
) -1;
1871 /* If this is a weak symbol, and there is a real definition, the
1872 processor independent code will have arranged for us to see the
1873 real definition first, and we can just use the same value. */
1874 if (h
->u
.weakdef
!= NULL
)
1876 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1877 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1878 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1879 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1880 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1881 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1885 /* This is a reference to a symbol defined by a dynamic object which
1886 is not a function. */
1888 /* If we are creating a shared library, we must presume that the
1889 only references to the symbol are via the global offset table.
1890 For such cases we need not do anything here; the relocations will
1891 be handled correctly by relocate_section. */
1895 /* If there are no references to this symbol that do not use the
1896 GOT, we don't need to generate a copy reloc. */
1897 if (!h
->non_got_ref
)
1900 /* If -z nocopyreloc was given, we won't generate them either. */
1901 if (info
->nocopyreloc
)
1907 htab
= elf_i386_hash_table (info
);
1909 /* If there aren't any dynamic relocs in read-only sections, then
1910 we can keep the dynamic relocs and avoid the copy reloc. This
1911 doesn't work on VxWorks, where we can not have dynamic relocations
1912 (other than copy and jump slot relocations) in an executable. */
1913 if (ELIMINATE_COPY_RELOCS
&& !htab
->is_vxworks
)
1915 struct elf_i386_link_hash_entry
* eh
;
1916 struct elf_i386_dyn_relocs
*p
;
1918 eh
= (struct elf_i386_link_hash_entry
*) h
;
1919 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1921 s
= p
->sec
->output_section
;
1922 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1935 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1936 h
->root
.root
.string
);
1940 /* We must allocate the symbol in our .dynbss section, which will
1941 become part of the .bss section of the executable. There will be
1942 an entry for this symbol in the .dynsym section. The dynamic
1943 object will contain position independent code, so all references
1944 from the dynamic object to this symbol will go through the global
1945 offset table. The dynamic linker will use the .dynsym entry to
1946 determine the address it must put in the global offset table, so
1947 both the dynamic object and the regular object will refer to the
1948 same memory location for the variable. */
1950 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1951 copy the initial value out of the dynamic object and into the
1952 runtime process image. */
1953 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1955 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
1961 return _bfd_elf_adjust_dynamic_copy (h
, s
);
1964 /* Allocate space in .plt, .got and associated reloc sections for
1968 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1970 struct bfd_link_info
*info
;
1971 struct elf_i386_link_hash_table
*htab
;
1972 struct elf_i386_link_hash_entry
*eh
;
1973 struct elf_i386_dyn_relocs
*p
;
1975 if (h
->root
.type
== bfd_link_hash_indirect
)
1978 if (h
->root
.type
== bfd_link_hash_warning
)
1979 /* When warning symbols are created, they **replace** the "real"
1980 entry in the hash table, thus we never get to see the real
1981 symbol in a hash traversal. So look at it now. */
1982 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1983 eh
= (struct elf_i386_link_hash_entry
*) h
;
1985 info
= (struct bfd_link_info
*) inf
;
1986 htab
= elf_i386_hash_table (info
);
1988 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1989 here if it is defined and referenced in a non-shared object. */
1990 if (h
->type
== STT_GNU_IFUNC
1993 asection
*plt
, *gotplt
, *relplt
;
1995 /* Return and discard space for dynamic relocations against it if
1996 it is never referenced in a non-shared object. */
1997 if (!h
->ref_regular
)
1999 if (h
->plt
.refcount
> 0
2000 || h
->got
.refcount
> 0)
2002 h
->got
.offset
= (bfd_vma
) -1;
2003 eh
->dyn_relocs
= NULL
;
2007 /* When building a static executable, use .iplt, .igot.plt and
2008 .rel.iplt sections for STT_GNU_IFUNC symbols. */
2009 if (htab
->splt
!= NULL
)
2012 gotplt
= htab
->sgotplt
;
2013 relplt
= htab
->srelplt
;
2015 /* If this is the first .plt entry, make room for the special
2018 plt
->size
+= PLT_ENTRY_SIZE
;
2023 gotplt
= htab
->igotplt
;
2024 relplt
= htab
->irelplt
;
2027 /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
2028 the original value for R_386_IRELATIVE. */
2029 h
->plt
.offset
= plt
->size
;
2031 /* Make room for this entry in the .plt/.iplt section. */
2032 plt
->size
+= PLT_ENTRY_SIZE
;
2034 /* We also need to make an entry in the .got.plt/.got.iplt
2035 section, which will be placed in the .got section by the
2039 /* We also need to make an entry in the .rela.plt/.rela.iplt
2041 relplt
->size
+= sizeof (Elf32_External_Rel
);
2042 relplt
->reloc_count
++;
2044 /* We need dynamic relocation for STT_GNU_IFUNC symbol only
2045 when there is a non-GOT reference in a shared object. */
2048 eh
->dyn_relocs
= NULL
;
2050 /* Finally, allocate space. */
2051 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2052 htab
->irelifunc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2054 /* For STT_GNU_IFUNC symbol, .got.plt has the real function
2055 addres and .got has the PLT entry adddress. We will load
2056 the GOT entry with the PLT entry in finish_dynamic_symbol if
2057 it is used. For branch, it uses .got.plt. For symbol value,
2058 1. Use .got.plt in a shared object if it is forced local or
2060 2. Use .got.plt in a non-shared object if pointer equality
2062 3. Use .got.plt if .got isn't used.
2063 4. Otherwise use .got so that it can be shared among different
2064 objects at run-time.
2065 We only need to relocate .got entry in shared object. */
2067 && (h
->dynindx
== -1
2068 || h
->forced_local
))
2070 && !h
->pointer_equality_needed
)
2071 || htab
->sgot
== NULL
)
2074 h
->got
.offset
= (bfd_vma
) -1;
2078 h
->got
.offset
= htab
->sgot
->size
;
2079 htab
->sgot
->size
+= 4;
2081 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2086 else if (htab
->elf
.dynamic_sections_created
2087 && h
->plt
.refcount
> 0)
2089 /* Make sure this symbol is output as a dynamic symbol.
2090 Undefined weak syms won't yet be marked as dynamic. */
2091 if (h
->dynindx
== -1
2092 && !h
->forced_local
)
2094 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2099 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2101 asection
*s
= htab
->splt
;
2103 /* If this is the first .plt entry, make room for the special
2106 s
->size
+= PLT_ENTRY_SIZE
;
2108 h
->plt
.offset
= s
->size
;
2110 /* If this symbol is not defined in a regular file, and we are
2111 not generating a shared library, then set the symbol to this
2112 location in the .plt. This is required to make function
2113 pointers compare as equal between the normal executable and
2114 the shared library. */
2118 h
->root
.u
.def
.section
= s
;
2119 h
->root
.u
.def
.value
= h
->plt
.offset
;
2122 /* Make room for this entry. */
2123 s
->size
+= PLT_ENTRY_SIZE
;
2125 /* We also need to make an entry in the .got.plt section, which
2126 will be placed in the .got section by the linker script. */
2127 htab
->sgotplt
->size
+= 4;
2129 /* We also need to make an entry in the .rel.plt section. */
2130 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2131 htab
->next_tls_desc_index
++;
2133 if (htab
->is_vxworks
&& !info
->shared
)
2135 /* VxWorks has a second set of relocations for each PLT entry
2136 in executables. They go in a separate relocation section,
2137 which is processed by the kernel loader. */
2139 /* There are two relocations for the initial PLT entry: an
2140 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2141 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2143 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
2144 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2146 /* There are two extra relocations for each subsequent PLT entry:
2147 an R_386_32 relocation for the GOT entry, and an R_386_32
2148 relocation for the PLT entry. */
2150 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2155 h
->plt
.offset
= (bfd_vma
) -1;
2161 h
->plt
.offset
= (bfd_vma
) -1;
2165 eh
->tlsdesc_got
= (bfd_vma
) -1;
2167 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2168 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2169 if (h
->got
.refcount
> 0
2172 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2173 h
->got
.offset
= (bfd_vma
) -1;
2174 else if (h
->got
.refcount
> 0)
2178 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2180 /* Make sure this symbol is output as a dynamic symbol.
2181 Undefined weak syms won't yet be marked as dynamic. */
2182 if (h
->dynindx
== -1
2183 && !h
->forced_local
)
2185 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2190 if (GOT_TLS_GDESC_P (tls_type
))
2192 eh
->tlsdesc_got
= htab
->sgotplt
->size
2193 - elf_i386_compute_jump_table_size (htab
);
2194 htab
->sgotplt
->size
+= 8;
2195 h
->got
.offset
= (bfd_vma
) -2;
2197 if (! GOT_TLS_GDESC_P (tls_type
)
2198 || GOT_TLS_GD_P (tls_type
))
2200 h
->got
.offset
= s
->size
;
2202 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2203 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2206 dyn
= htab
->elf
.dynamic_sections_created
;
2207 /* R_386_TLS_IE_32 needs one dynamic relocation,
2208 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2209 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2210 need two), R_386_TLS_GD needs one if local symbol and two if
2212 if (tls_type
== GOT_TLS_IE_BOTH
)
2213 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2214 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2215 || (tls_type
& GOT_TLS_IE
))
2216 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2217 else if (GOT_TLS_GD_P (tls_type
))
2218 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2219 else if (! GOT_TLS_GDESC_P (tls_type
)
2220 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2221 || h
->root
.type
!= bfd_link_hash_undefweak
)
2223 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2224 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2225 if (GOT_TLS_GDESC_P (tls_type
))
2226 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2229 h
->got
.offset
= (bfd_vma
) -1;
2231 if (eh
->dyn_relocs
== NULL
)
2234 /* In the shared -Bsymbolic case, discard space allocated for
2235 dynamic pc-relative relocs against symbols which turn out to be
2236 defined in regular objects. For the normal shared case, discard
2237 space for pc-relative relocs that have become local due to symbol
2238 visibility changes. */
2242 /* The only reloc that uses pc_count is R_386_PC32, which will
2243 appear on a call or on something like ".long foo - .". We
2244 want calls to protected symbols to resolve directly to the
2245 function rather than going via the plt. If people want
2246 function pointer comparisons to work as expected then they
2247 should avoid writing assembly like ".long foo - .". */
2248 if (SYMBOL_CALLS_LOCAL (info
, h
))
2250 struct elf_i386_dyn_relocs
**pp
;
2252 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2254 p
->count
-= p
->pc_count
;
2263 if (htab
->is_vxworks
)
2265 struct elf_i386_dyn_relocs
**pp
;
2266 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2268 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2275 /* Also discard relocs on undefined weak syms with non-default
2277 if (eh
->dyn_relocs
!= NULL
2278 && h
->root
.type
== bfd_link_hash_undefweak
)
2280 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2281 eh
->dyn_relocs
= NULL
;
2283 /* Make sure undefined weak symbols are output as a dynamic
2285 else if (h
->dynindx
== -1
2286 && !h
->forced_local
)
2288 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2293 else if (ELIMINATE_COPY_RELOCS
)
2295 /* For the non-shared case, discard space for relocs against
2296 symbols which turn out to need copy relocs or are not
2302 || (htab
->elf
.dynamic_sections_created
2303 && (h
->root
.type
== bfd_link_hash_undefweak
2304 || h
->root
.type
== bfd_link_hash_undefined
))))
2306 /* Make sure this symbol is output as a dynamic symbol.
2307 Undefined weak syms won't yet be marked as dynamic. */
2308 if (h
->dynindx
== -1
2309 && !h
->forced_local
)
2311 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2315 /* If that succeeded, we know we'll be keeping all the
2317 if (h
->dynindx
!= -1)
2321 eh
->dyn_relocs
= NULL
;
2326 /* Finally, allocate space. */
2327 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2331 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2333 BFD_ASSERT (sreloc
!= NULL
);
2334 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2340 /* Find any dynamic relocs that apply to read-only sections. */
2343 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2345 struct elf_i386_link_hash_entry
*eh
;
2346 struct elf_i386_dyn_relocs
*p
;
2348 if (h
->root
.type
== bfd_link_hash_warning
)
2349 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2351 eh
= (struct elf_i386_link_hash_entry
*) h
;
2352 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2354 asection
*s
= p
->sec
->output_section
;
2356 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2358 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2360 info
->flags
|= DF_TEXTREL
;
2362 /* Not an error, just cut short the traversal. */
2369 /* Set the sizes of the dynamic sections. */
2372 elf_i386_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2373 struct bfd_link_info
*info
)
2375 struct elf_i386_link_hash_table
*htab
;
2381 htab
= elf_i386_hash_table (info
);
2382 dynobj
= htab
->elf
.dynobj
;
2386 if (htab
->elf
.dynamic_sections_created
)
2388 /* Set the contents of the .interp section to the interpreter. */
2389 if (info
->executable
)
2391 s
= bfd_get_section_by_name (dynobj
, ".interp");
2394 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2395 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2399 /* Set up .got offsets for local syms, and space for local dynamic
2401 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2403 bfd_signed_vma
*local_got
;
2404 bfd_signed_vma
*end_local_got
;
2405 char *local_tls_type
;
2406 bfd_vma
*local_tlsdesc_gotent
;
2407 bfd_size_type locsymcount
;
2408 Elf_Internal_Shdr
*symtab_hdr
;
2411 if (! is_i386_elf (ibfd
))
2414 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2416 struct elf_i386_dyn_relocs
*p
;
2418 for (p
= ((struct elf_i386_dyn_relocs
*)
2419 elf_section_data (s
)->local_dynrel
);
2423 if (!bfd_is_abs_section (p
->sec
)
2424 && bfd_is_abs_section (p
->sec
->output_section
))
2426 /* Input section has been discarded, either because
2427 it is a copy of a linkonce section or due to
2428 linker script /DISCARD/, so we'll be discarding
2431 else if (htab
->is_vxworks
2432 && strcmp (p
->sec
->output_section
->name
,
2435 /* Relocations in vxworks .tls_vars sections are
2436 handled specially by the loader. */
2438 else if (p
->count
!= 0)
2440 srel
= elf_section_data (p
->sec
)->sreloc
;
2441 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2442 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2443 info
->flags
|= DF_TEXTREL
;
2448 local_got
= elf_local_got_refcounts (ibfd
);
2452 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2453 locsymcount
= symtab_hdr
->sh_info
;
2454 end_local_got
= local_got
+ locsymcount
;
2455 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
2456 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
2458 srel
= htab
->srelgot
;
2459 for (; local_got
< end_local_got
;
2460 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2462 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2465 if (GOT_TLS_GDESC_P (*local_tls_type
))
2467 *local_tlsdesc_gotent
= htab
->sgotplt
->size
2468 - elf_i386_compute_jump_table_size (htab
);
2469 htab
->sgotplt
->size
+= 8;
2470 *local_got
= (bfd_vma
) -2;
2472 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2473 || GOT_TLS_GD_P (*local_tls_type
))
2475 *local_got
= s
->size
;
2477 if (GOT_TLS_GD_P (*local_tls_type
)
2478 || *local_tls_type
== GOT_TLS_IE_BOTH
)
2482 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2483 || (*local_tls_type
& GOT_TLS_IE
))
2485 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
2486 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
2487 else if (GOT_TLS_GD_P (*local_tls_type
)
2488 || ! GOT_TLS_GDESC_P (*local_tls_type
))
2489 srel
->size
+= sizeof (Elf32_External_Rel
);
2490 if (GOT_TLS_GDESC_P (*local_tls_type
))
2491 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
2495 *local_got
= (bfd_vma
) -1;
2499 if (htab
->tls_ldm_got
.refcount
> 0)
2501 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2503 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2504 htab
->sgot
->size
+= 8;
2505 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2508 htab
->tls_ldm_got
.offset
= -1;
2510 /* Allocate global sym .plt and .got entries, and space for global
2511 sym dynamic relocs. */
2512 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
2514 /* For every jump slot reserved in the sgotplt, reloc_count is
2515 incremented. However, when we reserve space for TLS descriptors,
2516 it's not incremented, so in order to compute the space reserved
2517 for them, it suffices to multiply the reloc count by the jump
2520 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
2522 /* We now have determined the sizes of the various dynamic sections.
2523 Allocate memory for them. */
2525 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2527 bfd_boolean strip_section
= TRUE
;
2529 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2534 || s
== htab
->sgotplt
2536 || s
== htab
->igotplt
2537 || s
== htab
->sdynbss
)
2539 /* Strip this section if we don't need it; see the
2541 /* We'd like to strip these sections if they aren't needed, but if
2542 we've exported dynamic symbols from them we must leave them.
2543 It's too late to tell BFD to get rid of the symbols. */
2545 if (htab
->elf
.hplt
!= NULL
)
2546 strip_section
= FALSE
;
2548 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
2550 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
2553 /* We use the reloc_count field as a counter if we need
2554 to copy relocs into the output file. */
2559 /* It's not one of our sections, so don't allocate space. */
2565 /* If we don't need this section, strip it from the
2566 output file. This is mostly to handle .rel.bss and
2567 .rel.plt. We must create both sections in
2568 create_dynamic_sections, because they must be created
2569 before the linker maps input sections to output
2570 sections. The linker does that before
2571 adjust_dynamic_symbol is called, and it is that
2572 function which decides whether anything needs to go
2573 into these sections. */
2575 s
->flags
|= SEC_EXCLUDE
;
2579 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2582 /* Allocate memory for the section contents. We use bfd_zalloc
2583 here in case unused entries are not reclaimed before the
2584 section's contents are written out. This should not happen,
2585 but this way if it does, we get a R_386_NONE reloc instead
2587 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2588 if (s
->contents
== NULL
)
2592 if (htab
->elf
.dynamic_sections_created
)
2594 /* Add some entries to the .dynamic section. We fill in the
2595 values later, in elf_i386_finish_dynamic_sections, but we
2596 must add the entries now so that we get the correct size for
2597 the .dynamic section. The DT_DEBUG entry is filled in by the
2598 dynamic linker and used by the debugger. */
2599 #define add_dynamic_entry(TAG, VAL) \
2600 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2602 if (info
->executable
)
2604 if (!add_dynamic_entry (DT_DEBUG
, 0))
2608 if (htab
->splt
->size
!= 0)
2610 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2611 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2612 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2613 || !add_dynamic_entry (DT_JMPREL
, 0))
2619 if (!add_dynamic_entry (DT_REL
, 0)
2620 || !add_dynamic_entry (DT_RELSZ
, 0)
2621 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2624 /* If any dynamic relocs apply to a read-only section,
2625 then we need a DT_TEXTREL entry. */
2626 if ((info
->flags
& DF_TEXTREL
) == 0)
2627 elf_link_hash_traverse (&htab
->elf
,
2628 elf_i386_readonly_dynrelocs
, info
);
2630 if ((info
->flags
& DF_TEXTREL
) != 0)
2632 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2636 if (htab
->is_vxworks
2637 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
2640 #undef add_dynamic_entry
2646 elf_i386_always_size_sections (bfd
*output_bfd
,
2647 struct bfd_link_info
*info
)
2649 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2653 struct elf_link_hash_entry
*tlsbase
;
2655 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2656 "_TLS_MODULE_BASE_",
2657 FALSE
, FALSE
, FALSE
);
2659 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2661 struct bfd_link_hash_entry
*bh
= NULL
;
2662 const struct elf_backend_data
*bed
2663 = get_elf_backend_data (output_bfd
);
2665 if (!(_bfd_generic_link_add_one_symbol
2666 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2667 tls_sec
, 0, NULL
, FALSE
,
2668 bed
->collect
, &bh
)))
2671 elf_i386_hash_table (info
)->tls_module_base
= bh
;
2673 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2674 tlsbase
->def_regular
= 1;
2675 tlsbase
->other
= STV_HIDDEN
;
2676 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2683 /* Set the correct type for an x86 ELF section. We do this by the
2684 section name, which is a hack, but ought to work. */
2687 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2688 Elf_Internal_Shdr
*hdr
,
2691 register const char *name
;
2693 name
= bfd_get_section_name (abfd
, sec
);
2695 /* This is an ugly, but unfortunately necessary hack that is
2696 needed when producing EFI binaries on x86. It tells
2697 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2698 containing ELF relocation info. We need this hack in order to
2699 be able to generate ELF binaries that can be translated into
2700 EFI applications (which are essentially COFF objects). Those
2701 files contain a COFF ".reloc" section inside an ELFNN object,
2702 which would normally cause BFD to segfault because it would
2703 attempt to interpret this section as containing relocation
2704 entries for section "oc". With this hack enabled, ".reloc"
2705 will be treated as a normal data section, which will avoid the
2706 segfault. However, you won't be able to create an ELFNN binary
2707 with a section named "oc" that needs relocations, but that's
2708 the kind of ugly side-effects you get when detecting section
2709 types based on their names... In practice, this limitation is
2710 unlikely to bite. */
2711 if (strcmp (name
, ".reloc") == 0)
2712 hdr
->sh_type
= SHT_PROGBITS
;
2717 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2718 executables. Rather than setting it to the beginning of the TLS
2719 section, we have to set it to the end. This function may be called
2720 multiple times, it is idempotent. */
2723 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
2725 struct bfd_link_hash_entry
*base
;
2727 if (!info
->executable
)
2730 base
= elf_i386_hash_table (info
)->tls_module_base
;
2735 base
->u
.def
.value
= elf_hash_table (info
)->tls_size
;
2738 /* Return the base VMA address which should be subtracted from real addresses
2739 when resolving @dtpoff relocation.
2740 This is PT_TLS segment p_vaddr. */
2743 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
2745 /* If tls_sec is NULL, we should have signalled an error already. */
2746 if (elf_hash_table (info
)->tls_sec
== NULL
)
2748 return elf_hash_table (info
)->tls_sec
->vma
;
2751 /* Return the relocation value for @tpoff relocation
2752 if STT_TLS virtual address is ADDRESS. */
2755 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2757 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2759 /* If tls_sec is NULL, we should have signalled an error already. */
2760 if (htab
->tls_sec
== NULL
)
2762 return htab
->tls_size
+ htab
->tls_sec
->vma
- address
;
2765 /* Relocate an i386 ELF section. */
2768 elf_i386_relocate_section (bfd
*output_bfd
,
2769 struct bfd_link_info
*info
,
2771 asection
*input_section
,
2773 Elf_Internal_Rela
*relocs
,
2774 Elf_Internal_Sym
*local_syms
,
2775 asection
**local_sections
)
2777 struct elf_i386_link_hash_table
*htab
;
2778 Elf_Internal_Shdr
*symtab_hdr
;
2779 struct elf_link_hash_entry
**sym_hashes
;
2780 bfd_vma
*local_got_offsets
;
2781 bfd_vma
*local_tlsdesc_gotents
;
2782 Elf_Internal_Rela
*rel
;
2783 Elf_Internal_Rela
*relend
;
2784 bfd_boolean is_vxworks_tls
;
2786 BFD_ASSERT (is_i386_elf (input_bfd
));
2788 htab
= elf_i386_hash_table (info
);
2789 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2790 sym_hashes
= elf_sym_hashes (input_bfd
);
2791 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2792 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2793 /* We have to handle relocations in vxworks .tls_vars sections
2794 specially, because the dynamic loader is 'weird'. */
2795 is_vxworks_tls
= (htab
->is_vxworks
&& info
->shared
2796 && !strcmp (input_section
->output_section
->name
,
2799 elf_i386_set_tls_module_base (info
);
2802 relend
= relocs
+ input_section
->reloc_count
;
2803 for (; rel
< relend
; rel
++)
2805 unsigned int r_type
;
2806 reloc_howto_type
*howto
;
2807 unsigned long r_symndx
;
2808 struct elf_link_hash_entry
*h
;
2809 Elf_Internal_Sym
*sym
;
2811 bfd_vma off
, offplt
;
2813 bfd_boolean unresolved_reloc
;
2814 bfd_reloc_status_type r
;
2818 r_type
= ELF32_R_TYPE (rel
->r_info
);
2819 if (r_type
== R_386_GNU_VTINHERIT
2820 || r_type
== R_386_GNU_VTENTRY
)
2823 if ((indx
= r_type
) >= R_386_standard
2824 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2825 >= R_386_ext
- R_386_standard
)
2826 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2827 >= R_386_irelative
- R_386_ext
))
2829 (*_bfd_error_handler
)
2830 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2831 input_bfd
, input_section
, r_type
);
2832 bfd_set_error (bfd_error_bad_value
);
2835 howto
= elf_howto_table
+ indx
;
2837 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2841 unresolved_reloc
= FALSE
;
2842 if (r_symndx
< symtab_hdr
->sh_info
)
2844 sym
= local_syms
+ r_symndx
;
2845 sec
= local_sections
[r_symndx
];
2846 relocation
= (sec
->output_section
->vma
2847 + sec
->output_offset
2850 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
2851 && ((sec
->flags
& SEC_MERGE
) != 0
2852 || (info
->relocatable
2853 && sec
->output_offset
!= 0)))
2856 bfd_byte
*where
= contents
+ rel
->r_offset
;
2858 switch (howto
->size
)
2861 addend
= bfd_get_8 (input_bfd
, where
);
2862 if (howto
->pc_relative
)
2864 addend
= (addend
^ 0x80) - 0x80;
2869 addend
= bfd_get_16 (input_bfd
, where
);
2870 if (howto
->pc_relative
)
2872 addend
= (addend
^ 0x8000) - 0x8000;
2877 addend
= bfd_get_32 (input_bfd
, where
);
2878 if (howto
->pc_relative
)
2880 addend
= (addend
^ 0x80000000) - 0x80000000;
2888 if (info
->relocatable
)
2889 addend
+= sec
->output_offset
;
2892 asection
*msec
= sec
;
2893 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
2895 addend
-= relocation
;
2896 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2899 switch (howto
->size
)
2902 /* FIXME: overflow checks. */
2903 if (howto
->pc_relative
)
2905 bfd_put_8 (input_bfd
, addend
, where
);
2908 if (howto
->pc_relative
)
2910 bfd_put_16 (input_bfd
, addend
, where
);
2913 if (howto
->pc_relative
)
2915 bfd_put_32 (input_bfd
, addend
, where
);
2924 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2925 r_symndx
, symtab_hdr
, sym_hashes
,
2927 unresolved_reloc
, warned
);
2930 if (sec
!= NULL
&& elf_discarded_section (sec
))
2932 /* For relocs against symbols from removed linkonce sections,
2933 or sections discarded by a linker script, we just want the
2934 section contents zeroed. Avoid any special processing. */
2935 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2941 if (info
->relocatable
)
2944 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2945 it here if it is defined in a non-shared object. */
2947 && h
->type
== STT_GNU_IFUNC
2950 asection
*plt
, *gotplt
, *base_got
;
2953 if ((input_section
->flags
& SEC_ALLOC
) == 0
2954 || h
->plt
.offset
== (bfd_vma
) -1)
2957 /* STT_GNU_IFUNC symbol must go through PLT. */
2958 if (htab
->splt
!= NULL
)
2961 gotplt
= htab
->sgotplt
;
2966 gotplt
= htab
->igotplt
;
2969 relocation
= (plt
->output_section
->vma
2970 + plt
->output_offset
+ h
->plt
.offset
);
2975 (*_bfd_error_handler
)
2976 (_("%B: relocation %s against STT_GNU_IFUNC "
2977 "symbol `%s' isn't handled by %s"), input_bfd
,
2978 elf_howto_table
[r_type
].name
,
2979 h
->root
.root
.string
, __FUNCTION__
);
2980 bfd_set_error (bfd_error_bad_value
);
2984 /* Generate dynamic relcoation only when there is a
2985 non-GOF reference in a shared object. */
2986 if (info
->shared
&& h
->non_got_ref
)
2988 Elf_Internal_Rela outrel
;
2993 /* Need a dynamic relocation get the the real
2994 function adddress. */
2995 offset
= _bfd_elf_section_offset (output_bfd
,
2999 if (offset
== (bfd_vma
) -1
3000 || offset
== (bfd_vma
) -2)
3003 outrel
.r_offset
= (input_section
->output_section
->vma
3004 + input_section
->output_offset
3007 if (h
->dynindx
== -1
3010 /* This symbol is resolved locally. */
3011 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3012 bfd_put_32 (output_bfd
,
3013 (h
->root
.u
.def
.value
3014 + h
->root
.u
.def
.section
->output_section
->vma
3015 + h
->root
.u
.def
.section
->output_offset
),
3019 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3021 sreloc
= htab
->irelifunc
;
3022 loc
= sreloc
->contents
;
3023 loc
+= (sreloc
->reloc_count
++
3024 * sizeof (Elf32_External_Rel
));
3025 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3027 /* If this reloc is against an external symbol, we
3028 do not want to fiddle with the addend. Otherwise,
3029 we need to include the symbol value so that it
3030 becomes an addend for the dynamic reloc. For an
3031 internal symbol, we have updated addend. */
3040 base_got
= htab
->sgot
;
3041 off
= h
->got
.offset
;
3043 if (base_got
== NULL
)
3046 if (off
== (bfd_vma
) -1)
3048 /* We can't use h->got.offset here to save state, or
3049 even just remember the offset, as finish_dynamic_symbol
3050 would use that as offset into .got. */
3052 if (htab
->splt
!= NULL
)
3054 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3055 off
= (plt_index
+ 3) * 4;
3056 base_got
= htab
->sgotplt
;
3060 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3061 off
= plt_index
* 4;
3062 base_got
= htab
->igotplt
;
3065 if (h
->dynindx
== -1
3069 /* This references the local defitionion. We must
3070 initialize this entry in the global offset table.
3071 Since the offset must always be a multiple of 8,
3072 we use the least significant bit to record
3073 whether we have initialized it already.
3075 When doing a dynamic link, we create a .rela.got
3076 relocation entry to initialize the value. This
3077 is done in the finish_dynamic_symbol routine. */
3082 bfd_put_32 (output_bfd
, relocation
,
3083 base_got
->contents
+ off
);
3090 /* Adjust for static executables. */
3091 if (htab
->splt
== NULL
)
3092 relocation
+= gotplt
->output_offset
;
3096 relocation
= (base_got
->output_section
->vma
3097 + base_got
->output_offset
+ off
3098 - gotplt
->output_section
->vma
3099 - gotplt
->output_offset
);
3100 /* Adjust for static executables. */
3101 if (htab
->splt
== NULL
)
3102 relocation
+= gotplt
->output_offset
;
3108 relocation
-= (gotplt
->output_section
->vma
3109 + gotplt
->output_offset
);
3117 /* Relocation is to the entry for this symbol in the global
3119 if (htab
->sgot
== NULL
)
3126 off
= h
->got
.offset
;
3127 dyn
= htab
->elf
.dynamic_sections_created
;
3128 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3130 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3131 || (ELF_ST_VISIBILITY (h
->other
)
3132 && h
->root
.type
== bfd_link_hash_undefweak
))
3134 /* This is actually a static link, or it is a
3135 -Bsymbolic link and the symbol is defined
3136 locally, or the symbol was forced to be local
3137 because of a version file. We must initialize
3138 this entry in the global offset table. Since the
3139 offset must always be a multiple of 4, we use the
3140 least significant bit to record whether we have
3141 initialized it already.
3143 When doing a dynamic link, we create a .rel.got
3144 relocation entry to initialize the value. This
3145 is done in the finish_dynamic_symbol routine. */
3150 bfd_put_32 (output_bfd
, relocation
,
3151 htab
->sgot
->contents
+ off
);
3156 unresolved_reloc
= FALSE
;
3160 if (local_got_offsets
== NULL
)
3163 off
= local_got_offsets
[r_symndx
];
3165 /* The offset must always be a multiple of 4. We use
3166 the least significant bit to record whether we have
3167 already generated the necessary reloc. */
3172 bfd_put_32 (output_bfd
, relocation
,
3173 htab
->sgot
->contents
+ off
);
3178 Elf_Internal_Rela outrel
;
3185 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3186 + htab
->sgot
->output_offset
3188 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3190 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3191 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3194 local_got_offsets
[r_symndx
] |= 1;
3198 if (off
>= (bfd_vma
) -2)
3201 relocation
= htab
->sgot
->output_section
->vma
3202 + htab
->sgot
->output_offset
+ off
3203 - htab
->sgotplt
->output_section
->vma
3204 - htab
->sgotplt
->output_offset
;
3208 /* Relocation is relative to the start of the global offset
3211 /* Check to make sure it isn't a protected function symbol
3212 for shared library since it may not be local when used
3213 as function address. We also need to make sure that a
3214 symbol is defined locally. */
3215 if (info
->shared
&& h
)
3217 if (!h
->def_regular
)
3221 switch (ELF_ST_VISIBILITY (h
->other
))
3224 v
= _("hidden symbol");
3227 v
= _("internal symbol");
3230 v
= _("protected symbol");
3237 (*_bfd_error_handler
)
3238 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3239 input_bfd
, v
, h
->root
.root
.string
);
3240 bfd_set_error (bfd_error_bad_value
);
3243 else if (!info
->executable
3244 && h
->type
== STT_FUNC
3245 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3247 (*_bfd_error_handler
)
3248 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3249 input_bfd
, h
->root
.root
.string
);
3250 bfd_set_error (bfd_error_bad_value
);
3255 /* Note that sgot is not involved in this
3256 calculation. We always want the start of .got.plt. If we
3257 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3258 permitted by the ABI, we might have to change this
3260 relocation
-= htab
->sgotplt
->output_section
->vma
3261 + htab
->sgotplt
->output_offset
;
3265 /* Use global offset table as symbol value. */
3266 relocation
= htab
->sgotplt
->output_section
->vma
3267 + htab
->sgotplt
->output_offset
;
3268 unresolved_reloc
= FALSE
;
3272 /* Relocation is to the entry for this symbol in the
3273 procedure linkage table. */
3275 /* Resolve a PLT32 reloc against a local symbol directly,
3276 without using the procedure linkage table. */
3280 if (h
->plt
.offset
== (bfd_vma
) -1
3281 || htab
->splt
== NULL
)
3283 /* We didn't make a PLT entry for this symbol. This
3284 happens when statically linking PIC code, or when
3285 using -Bsymbolic. */
3289 relocation
= (htab
->splt
->output_section
->vma
3290 + htab
->splt
->output_offset
3292 unresolved_reloc
= FALSE
;
3297 if ((input_section
->flags
& SEC_ALLOC
) == 0
3303 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3304 || h
->root
.type
!= bfd_link_hash_undefweak
)
3305 && (r_type
!= R_386_PC32
3306 || !SYMBOL_CALLS_LOCAL (info
, h
)))
3307 || (ELIMINATE_COPY_RELOCS
3314 || h
->root
.type
== bfd_link_hash_undefweak
3315 || h
->root
.type
== bfd_link_hash_undefined
)))
3317 Elf_Internal_Rela outrel
;
3319 bfd_boolean skip
, relocate
;
3322 /* When generating a shared object, these relocations
3323 are copied into the output file to be resolved at run
3330 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3332 if (outrel
.r_offset
== (bfd_vma
) -1)
3334 else if (outrel
.r_offset
== (bfd_vma
) -2)
3335 skip
= TRUE
, relocate
= TRUE
;
3336 outrel
.r_offset
+= (input_section
->output_section
->vma
3337 + input_section
->output_offset
);
3340 memset (&outrel
, 0, sizeof outrel
);
3343 && (r_type
== R_386_PC32
3345 || !SYMBOLIC_BIND (info
, h
)
3346 || !h
->def_regular
))
3347 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3350 /* This symbol is local, or marked to become local. */
3352 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3355 sreloc
= elf_section_data (input_section
)->sreloc
;
3357 BFD_ASSERT (sreloc
!= NULL
&& sreloc
->contents
!= NULL
);
3359 loc
= sreloc
->contents
;
3360 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3362 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3364 /* If this reloc is against an external symbol, we do
3365 not want to fiddle with the addend. Otherwise, we
3366 need to include the symbol value so that it becomes
3367 an addend for the dynamic reloc. */
3376 Elf_Internal_Rela outrel
;
3380 outrel
.r_offset
= rel
->r_offset
3381 + input_section
->output_section
->vma
3382 + input_section
->output_offset
;
3383 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3384 sreloc
= elf_section_data (input_section
)->sreloc
;
3387 loc
= sreloc
->contents
;
3388 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3389 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3394 case R_386_TLS_GOTDESC
:
3395 case R_386_TLS_DESC_CALL
:
3396 case R_386_TLS_IE_32
:
3397 case R_386_TLS_GOTIE
:
3398 tls_type
= GOT_UNKNOWN
;
3399 if (h
== NULL
&& local_got_offsets
)
3400 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
3402 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
3403 if (tls_type
== GOT_TLS_IE
)
3404 tls_type
= GOT_TLS_IE_NEG
;
3406 if (! elf_i386_tls_transition (info
, input_bfd
,
3407 input_section
, contents
,
3408 symtab_hdr
, sym_hashes
,
3409 &r_type
, tls_type
, rel
,
3413 if (r_type
== R_386_TLS_LE_32
)
3415 BFD_ASSERT (! unresolved_reloc
);
3416 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3421 /* GD->LE transition. */
3422 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3425 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3427 movl %gs:0, %eax; subl $foo@tpoff, %eax
3428 (6 byte form of subl). */
3429 memcpy (contents
+ rel
->r_offset
- 3,
3430 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3431 roff
= rel
->r_offset
+ 5;
3435 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3437 movl %gs:0, %eax; subl $foo@tpoff, %eax
3438 (6 byte form of subl). */
3439 memcpy (contents
+ rel
->r_offset
- 2,
3440 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3441 roff
= rel
->r_offset
+ 6;
3443 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3445 /* Skip R_386_PC32/R_386_PLT32. */
3449 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3451 /* GDesc -> LE transition.
3452 It's originally something like:
3453 leal x@tlsdesc(%ebx), %eax
3457 Registers other than %eax may be set up here. */
3462 roff
= rel
->r_offset
;
3463 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3465 /* Now modify the instruction as appropriate. */
3466 /* aoliva FIXME: remove the above and xor the byte
3468 bfd_put_8 (output_bfd
, val
^ 0x86,
3469 contents
+ roff
- 1);
3470 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3474 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3476 /* GDesc -> LE transition.
3484 roff
= rel
->r_offset
;
3485 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3486 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3489 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
3493 /* IE->LE transition:
3494 Originally it can be one of:
3502 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3505 /* movl foo, %eax. */
3506 bfd_put_8 (output_bfd
, 0xb8,
3507 contents
+ rel
->r_offset
- 1);
3513 type
= bfd_get_8 (input_bfd
,
3514 contents
+ rel
->r_offset
- 2);
3519 bfd_put_8 (output_bfd
, 0xc7,
3520 contents
+ rel
->r_offset
- 2);
3521 bfd_put_8 (output_bfd
,
3522 0xc0 | ((val
>> 3) & 7),
3523 contents
+ rel
->r_offset
- 1);
3527 bfd_put_8 (output_bfd
, 0x81,
3528 contents
+ rel
->r_offset
- 2);
3529 bfd_put_8 (output_bfd
,
3530 0xc0 | ((val
>> 3) & 7),
3531 contents
+ rel
->r_offset
- 1);
3538 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3539 contents
+ rel
->r_offset
);
3544 unsigned int val
, type
;
3546 /* {IE_32,GOTIE}->LE transition:
3547 Originally it can be one of:
3548 subl foo(%reg1), %reg2
3549 movl foo(%reg1), %reg2
3550 addl foo(%reg1), %reg2
3553 movl $foo, %reg2 (6 byte form)
3554 addl $foo, %reg2. */
3555 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3556 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3560 bfd_put_8 (output_bfd
, 0xc7,
3561 contents
+ rel
->r_offset
- 2);
3562 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3563 contents
+ rel
->r_offset
- 1);
3565 else if (type
== 0x2b)
3568 bfd_put_8 (output_bfd
, 0x81,
3569 contents
+ rel
->r_offset
- 2);
3570 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
3571 contents
+ rel
->r_offset
- 1);
3573 else if (type
== 0x03)
3576 bfd_put_8 (output_bfd
, 0x81,
3577 contents
+ rel
->r_offset
- 2);
3578 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3579 contents
+ rel
->r_offset
- 1);
3583 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
3584 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
3585 contents
+ rel
->r_offset
);
3587 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
3588 contents
+ rel
->r_offset
);
3593 if (htab
->sgot
== NULL
)
3598 off
= h
->got
.offset
;
3599 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
3603 if (local_got_offsets
== NULL
)
3606 off
= local_got_offsets
[r_symndx
];
3607 offplt
= local_tlsdesc_gotents
[r_symndx
];
3614 Elf_Internal_Rela outrel
;
3619 if (htab
->srelgot
== NULL
)
3622 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3624 if (GOT_TLS_GDESC_P (tls_type
))
3626 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
3627 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
3628 <= htab
->sgotplt
->size
);
3629 outrel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3630 + htab
->sgotplt
->output_offset
3632 + htab
->sgotplt_jump_table_size
);
3633 sreloc
= htab
->srelplt
;
3634 loc
= sreloc
->contents
;
3635 loc
+= (htab
->next_tls_desc_index
++
3636 * sizeof (Elf32_External_Rel
));
3637 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3638 <= sreloc
->contents
+ sreloc
->size
);
3639 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3642 BFD_ASSERT (! unresolved_reloc
);
3643 bfd_put_32 (output_bfd
,
3644 relocation
- elf_i386_dtpoff_base (info
),
3645 htab
->sgotplt
->contents
+ offplt
3646 + htab
->sgotplt_jump_table_size
+ 4);
3650 bfd_put_32 (output_bfd
, 0,
3651 htab
->sgotplt
->contents
+ offplt
3652 + htab
->sgotplt_jump_table_size
+ 4);
3656 sreloc
= htab
->srelgot
;
3658 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3659 + htab
->sgot
->output_offset
+ off
);
3661 if (GOT_TLS_GD_P (tls_type
))
3662 dr_type
= R_386_TLS_DTPMOD32
;
3663 else if (GOT_TLS_GDESC_P (tls_type
))
3665 else if (tls_type
== GOT_TLS_IE_POS
)
3666 dr_type
= R_386_TLS_TPOFF
;
3668 dr_type
= R_386_TLS_TPOFF32
;
3670 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3671 bfd_put_32 (output_bfd
,
3672 relocation
- elf_i386_dtpoff_base (info
),
3673 htab
->sgot
->contents
+ off
);
3674 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3675 bfd_put_32 (output_bfd
,
3676 elf_i386_dtpoff_base (info
) - relocation
,
3677 htab
->sgot
->contents
+ off
);
3678 else if (dr_type
!= R_386_TLS_DESC
)
3679 bfd_put_32 (output_bfd
, 0,
3680 htab
->sgot
->contents
+ off
);
3681 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3683 loc
= sreloc
->contents
;
3684 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3685 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3686 <= sreloc
->contents
+ sreloc
->size
);
3687 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3689 if (GOT_TLS_GD_P (tls_type
))
3693 BFD_ASSERT (! unresolved_reloc
);
3694 bfd_put_32 (output_bfd
,
3695 relocation
- elf_i386_dtpoff_base (info
),
3696 htab
->sgot
->contents
+ off
+ 4);
3700 bfd_put_32 (output_bfd
, 0,
3701 htab
->sgot
->contents
+ off
+ 4);
3702 outrel
.r_info
= ELF32_R_INFO (indx
,
3703 R_386_TLS_DTPOFF32
);
3704 outrel
.r_offset
+= 4;
3705 sreloc
->reloc_count
++;
3706 loc
+= sizeof (Elf32_External_Rel
);
3707 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3708 <= sreloc
->contents
+ sreloc
->size
);
3709 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3712 else if (tls_type
== GOT_TLS_IE_BOTH
)
3714 bfd_put_32 (output_bfd
,
3716 ? relocation
- elf_i386_dtpoff_base (info
)
3718 htab
->sgot
->contents
+ off
+ 4);
3719 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3720 outrel
.r_offset
+= 4;
3721 sreloc
->reloc_count
++;
3722 loc
+= sizeof (Elf32_External_Rel
);
3723 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3730 local_got_offsets
[r_symndx
] |= 1;
3733 if (off
>= (bfd_vma
) -2
3734 && ! GOT_TLS_GDESC_P (tls_type
))
3736 if (r_type
== R_386_TLS_GOTDESC
3737 || r_type
== R_386_TLS_DESC_CALL
)
3739 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3740 unresolved_reloc
= FALSE
;
3742 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3744 bfd_vma g_o_t
= htab
->sgotplt
->output_section
->vma
3745 + htab
->sgotplt
->output_offset
;
3746 relocation
= htab
->sgot
->output_section
->vma
3747 + htab
->sgot
->output_offset
+ off
- g_o_t
;
3748 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3749 && tls_type
== GOT_TLS_IE_BOTH
)
3751 if (r_type
== R_386_TLS_IE
)
3752 relocation
+= g_o_t
;
3753 unresolved_reloc
= FALSE
;
3755 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3757 unsigned int val
, type
;
3760 /* GD->IE transition. */
3761 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3762 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3765 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3767 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3769 roff
= rel
->r_offset
- 3;
3773 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3775 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3776 roff
= rel
->r_offset
- 2;
3778 memcpy (contents
+ roff
,
3779 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3780 contents
[roff
+ 7] = 0x80 | (val
& 7);
3781 /* If foo is used only with foo@gotntpoff(%reg) and
3782 foo@indntpoff, but not with foo@gottpoff(%reg), change
3783 subl $foo@gottpoff(%reg), %eax
3785 addl $foo@gotntpoff(%reg), %eax. */
3786 if (tls_type
== GOT_TLS_IE_POS
)
3787 contents
[roff
+ 6] = 0x03;
3788 bfd_put_32 (output_bfd
,
3789 htab
->sgot
->output_section
->vma
3790 + htab
->sgot
->output_offset
+ off
3791 - htab
->sgotplt
->output_section
->vma
3792 - htab
->sgotplt
->output_offset
,
3793 contents
+ roff
+ 8);
3794 /* Skip R_386_PLT32. */
3798 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3800 /* GDesc -> IE transition.
3801 It's originally something like:
3802 leal x@tlsdesc(%ebx), %eax
3805 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3807 movl x@gottpoff(%ebx), %eax # before negl %eax
3809 Registers other than %eax may be set up here. */
3813 /* First, make sure it's a leal adding ebx to a 32-bit
3814 offset into any register, although it's probably
3815 almost always going to be eax. */
3816 roff
= rel
->r_offset
;
3818 /* Now modify the instruction as appropriate. */
3819 /* To turn a leal into a movl in the form we use it, it
3820 suffices to change the first byte from 0x8d to 0x8b.
3821 aoliva FIXME: should we decide to keep the leal, all
3822 we have to do is remove the statement below, and
3823 adjust the relaxation of R_386_TLS_DESC_CALL. */
3824 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3826 if (tls_type
== GOT_TLS_IE_BOTH
)
3829 bfd_put_32 (output_bfd
,
3830 htab
->sgot
->output_section
->vma
3831 + htab
->sgot
->output_offset
+ off
3832 - htab
->sgotplt
->output_section
->vma
3833 - htab
->sgotplt
->output_offset
,
3837 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3839 /* GDesc -> IE transition.
3847 depending on how we transformed the TLS_GOTDESC above.
3852 roff
= rel
->r_offset
;
3854 /* Now modify the instruction as appropriate. */
3855 if (tls_type
!= GOT_TLS_IE_NEG
)
3858 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3859 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3864 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
3865 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
3875 if (! elf_i386_tls_transition (info
, input_bfd
,
3876 input_section
, contents
,
3877 symtab_hdr
, sym_hashes
,
3878 &r_type
, GOT_UNKNOWN
, rel
,
3882 if (r_type
!= R_386_TLS_LDM
)
3884 /* LD->LE transition:
3885 leal foo(%reg), %eax; call ___tls_get_addr.
3887 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3888 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
3889 memcpy (contents
+ rel
->r_offset
- 2,
3890 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3891 /* Skip R_386_PC32/R_386_PLT32. */
3896 if (htab
->sgot
== NULL
)
3899 off
= htab
->tls_ldm_got
.offset
;
3904 Elf_Internal_Rela outrel
;
3907 if (htab
->srelgot
== NULL
)
3910 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3911 + htab
->sgot
->output_offset
+ off
);
3913 bfd_put_32 (output_bfd
, 0,
3914 htab
->sgot
->contents
+ off
);
3915 bfd_put_32 (output_bfd
, 0,
3916 htab
->sgot
->contents
+ off
+ 4);
3917 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
3918 loc
= htab
->srelgot
->contents
;
3919 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3920 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3921 htab
->tls_ldm_got
.offset
|= 1;
3923 relocation
= htab
->sgot
->output_section
->vma
3924 + htab
->sgot
->output_offset
+ off
3925 - htab
->sgotplt
->output_section
->vma
3926 - htab
->sgotplt
->output_offset
;
3927 unresolved_reloc
= FALSE
;
3930 case R_386_TLS_LDO_32
:
3931 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
3932 relocation
-= elf_i386_dtpoff_base (info
);
3934 /* When converting LDO to LE, we must negate. */
3935 relocation
= -elf_i386_tpoff (info
, relocation
);
3938 case R_386_TLS_LE_32
:
3942 Elf_Internal_Rela outrel
;
3947 outrel
.r_offset
= rel
->r_offset
3948 + input_section
->output_section
->vma
3949 + input_section
->output_offset
;
3950 if (h
!= NULL
&& h
->dynindx
!= -1)
3954 if (r_type
== R_386_TLS_LE_32
)
3955 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
3957 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3958 sreloc
= elf_section_data (input_section
)->sreloc
;
3961 loc
= sreloc
->contents
;
3962 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3963 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3966 else if (r_type
== R_386_TLS_LE_32
)
3967 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
3969 relocation
-= elf_i386_dtpoff_base (info
);
3971 else if (r_type
== R_386_TLS_LE_32
)
3972 relocation
= elf_i386_tpoff (info
, relocation
);
3974 relocation
= -elf_i386_tpoff (info
, relocation
);
3981 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3982 because such sections are not SEC_ALLOC and thus ld.so will
3983 not process them. */
3984 if (unresolved_reloc
3985 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3988 (*_bfd_error_handler
)
3989 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3992 (long) rel
->r_offset
,
3994 h
->root
.root
.string
);
3999 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4000 contents
, rel
->r_offset
,
4003 if (r
!= bfd_reloc_ok
)
4008 name
= h
->root
.root
.string
;
4011 name
= bfd_elf_string_from_elf_section (input_bfd
,
4012 symtab_hdr
->sh_link
,
4017 name
= bfd_section_name (input_bfd
, sec
);
4020 if (r
== bfd_reloc_overflow
)
4022 if (! ((*info
->callbacks
->reloc_overflow
)
4023 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4024 (bfd_vma
) 0, input_bfd
, input_section
,
4030 (*_bfd_error_handler
)
4031 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4032 input_bfd
, input_section
,
4033 (long) rel
->r_offset
, name
, (int) r
);
4042 /* Finish up dynamic symbol handling. We set the contents of various
4043 dynamic sections here. */
4046 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
4047 struct bfd_link_info
*info
,
4048 struct elf_link_hash_entry
*h
,
4049 Elf_Internal_Sym
*sym
)
4051 struct elf_i386_link_hash_table
*htab
;
4053 htab
= elf_i386_hash_table (info
);
4055 if (h
->plt
.offset
!= (bfd_vma
) -1)
4059 Elf_Internal_Rela rel
;
4061 asection
*plt
, *gotplt
, *relplt
;
4063 /* When building a static executable, use .iplt, .igot.plt and
4064 .rel.iplt sections for STT_GNU_IFUNC symbols. */
4065 if (htab
->splt
!= NULL
)
4068 gotplt
= htab
->sgotplt
;
4069 relplt
= htab
->srelplt
;
4074 gotplt
= htab
->igotplt
;
4075 relplt
= htab
->irelplt
;
4078 /* This symbol has an entry in the procedure linkage table. Set
4081 if ((h
->dynindx
== -1
4082 && !((h
->forced_local
|| info
->executable
)
4084 && h
->type
== STT_GNU_IFUNC
))
4090 /* Get the index in the procedure linkage table which
4091 corresponds to this symbol. This is the index of this symbol
4092 in all the symbols for which we are making plt entries. The
4093 first entry in the procedure linkage table is reserved.
4095 Get the offset into the .got table of the entry that
4096 corresponds to this function. Each .got entry is 4 bytes.
4097 The first three are reserved.
4099 For static executables, we don't reserve anything. */
4101 if (plt
== htab
->splt
)
4103 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
4104 got_offset
= (plt_index
+ 3) * 4;
4108 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
4109 got_offset
= plt_index
* 4;
4112 /* Fill in the entry in the procedure linkage table. */
4115 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
4117 bfd_put_32 (output_bfd
,
4118 (gotplt
->output_section
->vma
4119 + gotplt
->output_offset
4121 plt
->contents
+ h
->plt
.offset
+ 2);
4123 if (htab
->is_vxworks
)
4125 int s
, k
, reloc_index
;
4127 /* Create the R_386_32 relocation referencing the GOT
4128 for this PLT entry. */
4130 /* S: Current slot number (zero-based). */
4131 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
4132 /* K: Number of relocations for PLTResolve. */
4134 k
= PLTRESOLVE_RELOCS_SHLIB
;
4136 k
= PLTRESOLVE_RELOCS
;
4137 /* Skip the PLTresolve relocations, and the relocations for
4138 the other PLT slots. */
4139 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
4140 loc
= (htab
->srelplt2
->contents
+ reloc_index
4141 * sizeof (Elf32_External_Rel
));
4143 rel
.r_offset
= (htab
->splt
->output_section
->vma
4144 + htab
->splt
->output_offset
4145 + h
->plt
.offset
+ 2),
4146 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4147 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4149 /* Create the R_386_32 relocation referencing the beginning of
4150 the PLT for this GOT entry. */
4151 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
4152 + htab
->sgotplt
->output_offset
4154 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4155 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4156 loc
+ sizeof (Elf32_External_Rel
));
4161 memcpy (plt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
4163 bfd_put_32 (output_bfd
, got_offset
,
4164 plt
->contents
+ h
->plt
.offset
+ 2);
4167 /* Don't fill PLT entry for static executables. */
4168 if (plt
== htab
->splt
)
4170 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
4171 plt
->contents
+ h
->plt
.offset
+ 7);
4172 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
4173 plt
->contents
+ h
->plt
.offset
+ 12);
4176 /* Fill in the entry in the global offset table. */
4177 bfd_put_32 (output_bfd
,
4178 (plt
->output_section
->vma
4179 + plt
->output_offset
4182 gotplt
->contents
+ got_offset
);
4184 /* Fill in the entry in the .rel.plt section. */
4185 rel
.r_offset
= (gotplt
->output_section
->vma
4186 + gotplt
->output_offset
4188 if (h
->dynindx
== -1
4189 || ((info
->executable
4190 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4192 && h
->type
== STT_GNU_IFUNC
))
4194 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4195 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4196 in the .got.plt section. */
4197 bfd_put_32 (output_bfd
,
4198 (h
->root
.u
.def
.value
4199 + h
->root
.u
.def
.section
->output_section
->vma
4200 + h
->root
.u
.def
.section
->output_offset
),
4201 gotplt
->contents
+ got_offset
);
4202 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4205 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
4206 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
4207 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4209 if (!h
->def_regular
)
4211 /* Mark the symbol as undefined, rather than as defined in
4212 the .plt section. Leave the value if there were any
4213 relocations where pointer equality matters (this is a clue
4214 for the dynamic linker, to make function pointer
4215 comparisons work between an application and shared
4216 library), otherwise set it to zero. If a function is only
4217 called from a binary, there is no need to slow down
4218 shared libraries because of that. */
4219 sym
->st_shndx
= SHN_UNDEF
;
4220 if (!h
->pointer_equality_needed
)
4225 if (h
->got
.offset
!= (bfd_vma
) -1
4226 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
4227 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
4229 Elf_Internal_Rela rel
;
4232 /* This symbol has an entry in the global offset table. Set it
4235 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
4238 rel
.r_offset
= (htab
->sgot
->output_section
->vma
4239 + htab
->sgot
->output_offset
4240 + (h
->got
.offset
& ~(bfd_vma
) 1));
4242 /* If this is a static link, or it is a -Bsymbolic link and the
4243 symbol is defined locally or was forced to be local because
4244 of a version file, we just want to emit a RELATIVE reloc.
4245 The entry in the global offset table will already have been
4246 initialized in the relocate_section function. */
4248 && h
->type
== STT_GNU_IFUNC
)
4252 /* Generate R_386_GLOB_DAT. */
4257 if (!h
->pointer_equality_needed
)
4260 /* For non-shared object, we can't use .got.plt, which
4261 contains the real function addres if we need pointer
4262 equality. We load the GOT entry with the PLT entry. */
4263 asection
*plt
= htab
->splt
? htab
->splt
: htab
->iplt
;
4264 bfd_put_32 (output_bfd
,
4265 (plt
->output_section
->vma
4266 + plt
->output_offset
+ h
->plt
.offset
),
4267 htab
->sgot
->contents
+ h
->got
.offset
);
4271 else if (info
->shared
4272 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4274 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4275 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4279 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4281 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4282 htab
->sgot
->contents
+ h
->got
.offset
);
4283 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
4286 loc
= htab
->srelgot
->contents
;
4287 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4288 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4293 Elf_Internal_Rela rel
;
4296 /* This symbol needs a copy reloc. Set it up. */
4298 if (h
->dynindx
== -1
4299 || (h
->root
.type
!= bfd_link_hash_defined
4300 && h
->root
.type
!= bfd_link_hash_defweak
)
4301 || htab
->srelbss
== NULL
)
4304 rel
.r_offset
= (h
->root
.u
.def
.value
4305 + h
->root
.u
.def
.section
->output_section
->vma
4306 + h
->root
.u
.def
.section
->output_offset
);
4307 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
4308 loc
= htab
->srelbss
->contents
;
4309 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
4310 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4313 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
4314 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
4315 is relative to the ".got" section. */
4316 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4317 || (!htab
->is_vxworks
&& h
== htab
->elf
.hgot
))
4318 sym
->st_shndx
= SHN_ABS
;
4323 /* Used to decide how to sort relocs in an optimal manner for the
4324 dynamic linker, before writing them out. */
4326 static enum elf_reloc_type_class
4327 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
4329 switch (ELF32_R_TYPE (rela
->r_info
))
4331 case R_386_RELATIVE
:
4332 return reloc_class_relative
;
4333 case R_386_JUMP_SLOT
:
4334 return reloc_class_plt
;
4336 return reloc_class_copy
;
4338 return reloc_class_normal
;
4342 /* Finish up the dynamic sections. */
4345 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
4346 struct bfd_link_info
*info
)
4348 struct elf_i386_link_hash_table
*htab
;
4352 htab
= elf_i386_hash_table (info
);
4353 dynobj
= htab
->elf
.dynobj
;
4354 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4356 if (htab
->elf
.dynamic_sections_created
)
4358 Elf32_External_Dyn
*dyncon
, *dynconend
;
4360 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
4363 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4364 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4365 for (; dyncon
< dynconend
; dyncon
++)
4367 Elf_Internal_Dyn dyn
;
4370 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4375 if (htab
->is_vxworks
4376 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
4382 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4387 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4392 dyn
.d_un
.d_val
= s
->size
;
4396 /* My reading of the SVR4 ABI indicates that the
4397 procedure linkage table relocs (DT_JMPREL) should be
4398 included in the overall relocs (DT_REL). This is
4399 what Solaris does. However, UnixWare can not handle
4400 that case. Therefore, we override the DT_RELSZ entry
4401 here to make it not include the JMPREL relocs. */
4405 dyn
.d_un
.d_val
-= s
->size
;
4409 /* We may not be using the standard ELF linker script.
4410 If .rel.plt is the first .rel section, we adjust
4411 DT_REL to not include it. */
4415 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
4417 dyn
.d_un
.d_ptr
+= s
->size
;
4421 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4424 /* Fill in the first entry in the procedure linkage table. */
4425 if (htab
->splt
&& htab
->splt
->size
> 0)
4429 memcpy (htab
->splt
->contents
, elf_i386_pic_plt0_entry
,
4430 sizeof (elf_i386_pic_plt0_entry
));
4431 memset (htab
->splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
4432 htab
->plt0_pad_byte
,
4433 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
4437 memcpy (htab
->splt
->contents
, elf_i386_plt0_entry
,
4438 sizeof(elf_i386_plt0_entry
));
4439 memset (htab
->splt
->contents
+ sizeof (elf_i386_plt0_entry
),
4440 htab
->plt0_pad_byte
,
4441 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
4442 bfd_put_32 (output_bfd
,
4443 (htab
->sgotplt
->output_section
->vma
4444 + htab
->sgotplt
->output_offset
4446 htab
->splt
->contents
+ 2);
4447 bfd_put_32 (output_bfd
,
4448 (htab
->sgotplt
->output_section
->vma
4449 + htab
->sgotplt
->output_offset
4451 htab
->splt
->contents
+ 8);
4453 if (htab
->is_vxworks
)
4455 Elf_Internal_Rela rel
;
4457 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4458 On IA32 we use REL relocations so the addend goes in
4459 the PLT directly. */
4460 rel
.r_offset
= (htab
->splt
->output_section
->vma
4461 + htab
->splt
->output_offset
4463 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4464 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4465 htab
->srelplt2
->contents
);
4466 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
4467 rel
.r_offset
= (htab
->splt
->output_section
->vma
4468 + htab
->splt
->output_offset
4470 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4471 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
4472 htab
->srelplt2
->contents
+
4473 sizeof (Elf32_External_Rel
));
4477 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4478 really seem like the right value. */
4479 elf_section_data (htab
->splt
->output_section
)
4480 ->this_hdr
.sh_entsize
= 4;
4482 /* Correct the .rel.plt.unloaded relocations. */
4483 if (htab
->is_vxworks
&& !info
->shared
)
4485 int num_plts
= (htab
->splt
->size
/ PLT_ENTRY_SIZE
) - 1;
4488 p
= htab
->srelplt2
->contents
;
4490 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
4492 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
4494 for (; num_plts
; num_plts
--)
4496 Elf_Internal_Rela rel
;
4497 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4498 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
4499 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4500 p
+= sizeof (Elf32_External_Rel
);
4502 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
4503 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
4504 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
4505 p
+= sizeof (Elf32_External_Rel
);
4513 /* Fill in the first three entries in the global offset table. */
4514 if (htab
->sgotplt
->size
> 0)
4516 bfd_put_32 (output_bfd
,
4518 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
4519 htab
->sgotplt
->contents
);
4520 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 4);
4521 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 8);
4524 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
4527 if (htab
->sgot
&& htab
->sgot
->size
> 0)
4528 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4533 /* Return address for Ith PLT stub in section PLT, for relocation REL
4534 or (bfd_vma) -1 if it should not be included. */
4537 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
4538 const arelent
*rel ATTRIBUTE_UNUSED
)
4540 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4543 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4546 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
4548 if (h
->plt
.offset
!= (bfd_vma
) -1
4550 && !h
->pointer_equality_needed
)
4553 return _bfd_elf_hash_symbol (h
);
4556 /* Hook called by the linker routine which adds symbols from an object
4560 elf_i386_add_symbol_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
4561 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4562 Elf_Internal_Sym
* sym
,
4563 const char ** namep ATTRIBUTE_UNUSED
,
4564 flagword
* flagsp ATTRIBUTE_UNUSED
,
4565 asection
** secp ATTRIBUTE_UNUSED
,
4566 bfd_vma
* valp ATTRIBUTE_UNUSED
)
4568 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4569 elf_tdata (info
->output_bfd
)->has_ifunc_symbols
= TRUE
;
4574 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4575 #define TARGET_LITTLE_NAME "elf32-i386"
4576 #define ELF_ARCH bfd_arch_i386
4577 #define ELF_MACHINE_CODE EM_386
4578 #define ELF_MAXPAGESIZE 0x1000
4580 #define elf_backend_can_gc_sections 1
4581 #define elf_backend_can_refcount 1
4582 #define elf_backend_want_got_plt 1
4583 #define elf_backend_plt_readonly 1
4584 #define elf_backend_want_plt_sym 0
4585 #define elf_backend_got_header_size 12
4587 /* Support RELA for objdump of prelink objects. */
4588 #define elf_info_to_howto elf_i386_info_to_howto_rel
4589 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4591 #define bfd_elf32_mkobject elf_i386_mkobject
4593 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4594 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
4595 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
4596 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
4598 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
4599 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4600 #define elf_backend_check_relocs elf_i386_check_relocs
4601 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
4602 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
4603 #define elf_backend_fake_sections elf_i386_fake_sections
4604 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4605 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4606 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4607 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
4608 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
4609 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
4610 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
4611 #define elf_backend_relocate_section elf_i386_relocate_section
4612 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
4613 #define elf_backend_always_size_sections elf_i386_always_size_sections
4614 #define elf_backend_omit_section_dynsym \
4615 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4616 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
4617 #define elf_backend_hash_symbol elf_i386_hash_symbol
4618 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
4619 #undef elf_backend_post_process_headers
4620 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4622 #include "elf32-target.h"
4624 /* FreeBSD support. */
4626 #undef TARGET_LITTLE_SYM
4627 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4628 #undef TARGET_LITTLE_NAME
4629 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
4631 #define ELF_OSABI ELFOSABI_FREEBSD
4633 /* The kernel recognizes executables as valid only if they carry a
4634 "FreeBSD" label in the ELF header. So we put this label on all
4635 executables and (for simplicity) also all other object files. */
4638 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
4640 _bfd_elf_set_osabi (abfd
, info
);
4642 #ifdef OLD_FREEBSD_ABI_LABEL
4643 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4644 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
4648 #undef elf_backend_post_process_headers
4649 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
4651 #define elf32_bed elf32_i386_fbsd_bed
4653 #undef elf_backend_add_symbol_hook
4655 #include "elf32-target.h"
4657 /* VxWorks support. */
4659 #undef TARGET_LITTLE_SYM
4660 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4661 #undef TARGET_LITTLE_NAME
4662 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
4665 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
4667 static struct bfd_link_hash_table
*
4668 elf_i386_vxworks_link_hash_table_create (bfd
*abfd
)
4670 struct bfd_link_hash_table
*ret
;
4671 struct elf_i386_link_hash_table
*htab
;
4673 ret
= elf_i386_link_hash_table_create (abfd
);
4676 htab
= (struct elf_i386_link_hash_table
*) ret
;
4677 htab
->is_vxworks
= 1;
4678 htab
->plt0_pad_byte
= 0x90;
4685 #undef elf_backend_relocs_compatible
4686 #undef elf_backend_post_process_headers
4687 #undef bfd_elf32_bfd_link_hash_table_create
4688 #define bfd_elf32_bfd_link_hash_table_create \
4689 elf_i386_vxworks_link_hash_table_create
4690 #undef elf_backend_add_symbol_hook
4691 #define elf_backend_add_symbol_hook \
4692 elf_vxworks_add_symbol_hook
4693 #undef elf_backend_link_output_symbol_hook
4694 #define elf_backend_link_output_symbol_hook \
4695 elf_vxworks_link_output_symbol_hook
4696 #undef elf_backend_emit_relocs
4697 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4698 #undef elf_backend_final_write_processing
4699 #define elf_backend_final_write_processing \
4700 elf_vxworks_final_write_processing
4702 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4704 #undef elf_backend_want_plt_sym
4705 #define elf_backend_want_plt_sym 1
4708 #define elf32_bed elf32_i386_vxworks_bed
4710 #include "elf32-target.h"