1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
32 #include "opcode/i386.h"
34 /* 386 uses REL relocations instead of RELA. */
39 static reloc_howto_type elf_howto_table
[]=
41 HOWTO(R_386_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
42 bfd_elf_generic_reloc
, "R_386_NONE",
43 TRUE
, 0x00000000, 0x00000000, FALSE
),
44 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
45 bfd_elf_generic_reloc
, "R_386_32",
46 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
47 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
48 bfd_elf_generic_reloc
, "R_386_PC32",
49 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
50 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
51 bfd_elf_generic_reloc
, "R_386_GOT32",
52 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
53 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_386_PLT32",
55 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
56 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
57 bfd_elf_generic_reloc
, "R_386_COPY",
58 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
59 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
60 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
61 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
62 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
64 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
65 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_386_RELATIVE",
67 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
68 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
, "R_386_GOTOFF",
70 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
71 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
72 bfd_elf_generic_reloc
, "R_386_GOTPC",
73 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
85 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
86 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_386_TLS_IE",
88 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
89 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
91 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
92 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_386_TLS_LE",
94 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
95 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_386_TLS_GD",
97 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
98 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
100 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
101 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_386_16",
103 TRUE
, 0xffff, 0xffff, FALSE
),
104 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_386_PC16",
106 TRUE
, 0xffff, 0xffff, TRUE
),
107 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_386_8",
109 TRUE
, 0xff, 0xff, FALSE
),
110 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_386_PC8",
112 TRUE
, 0xff, 0xff, TRUE
),
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
118 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
119 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
120 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
122 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
123 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
125 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
126 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
128 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
129 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
131 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
132 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
133 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
134 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
135 HOWTO(R_386_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
136 bfd_elf_generic_reloc
, "R_386_SIZE32",
137 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
138 HOWTO(R_386_TLS_GOTDESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
139 bfd_elf_generic_reloc
, "R_386_TLS_GOTDESC",
140 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
141 HOWTO(R_386_TLS_DESC_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
142 bfd_elf_generic_reloc
, "R_386_TLS_DESC_CALL",
144 HOWTO(R_386_TLS_DESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
145 bfd_elf_generic_reloc
, "R_386_TLS_DESC",
146 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
147 HOWTO(R_386_IRELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
148 bfd_elf_generic_reloc
, "R_386_IRELATIVE",
149 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
150 HOWTO(R_386_GOT32X
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
151 bfd_elf_generic_reloc
, "R_386_GOT32X",
152 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
155 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
156 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
158 /* GNU extension to record C++ vtable hierarchy. */
159 HOWTO (R_386_GNU_VTINHERIT
, /* type */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
163 FALSE
, /* pc_relative */
165 complain_overflow_dont
, /* complain_on_overflow */
166 NULL
, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
168 FALSE
, /* partial_inplace */
171 FALSE
), /* pcrel_offset */
173 /* GNU extension to record C++ vtable member usage. */
174 HOWTO (R_386_GNU_VTENTRY
, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE
, /* pc_relative */
180 complain_overflow_dont
, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
183 FALSE
, /* partial_inplace */
186 FALSE
) /* pcrel_offset */
188 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
192 #ifdef DEBUG_GEN_RELOC
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
199 static reloc_howto_type
*
200 elf_i386_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
201 bfd_reloc_code_real_type code
)
206 TRACE ("BFD_RELOC_NONE");
207 return &elf_howto_table
[R_386_NONE
];
210 TRACE ("BFD_RELOC_32");
211 return &elf_howto_table
[R_386_32
];
214 TRACE ("BFD_RELOC_CTOR");
215 return &elf_howto_table
[R_386_32
];
217 case BFD_RELOC_32_PCREL
:
218 TRACE ("BFD_RELOC_PC32");
219 return &elf_howto_table
[R_386_PC32
];
221 case BFD_RELOC_386_GOT32
:
222 TRACE ("BFD_RELOC_386_GOT32");
223 return &elf_howto_table
[R_386_GOT32
];
225 case BFD_RELOC_386_PLT32
:
226 TRACE ("BFD_RELOC_386_PLT32");
227 return &elf_howto_table
[R_386_PLT32
];
229 case BFD_RELOC_386_COPY
:
230 TRACE ("BFD_RELOC_386_COPY");
231 return &elf_howto_table
[R_386_COPY
];
233 case BFD_RELOC_386_GLOB_DAT
:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
235 return &elf_howto_table
[R_386_GLOB_DAT
];
237 case BFD_RELOC_386_JUMP_SLOT
:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
239 return &elf_howto_table
[R_386_JUMP_SLOT
];
241 case BFD_RELOC_386_RELATIVE
:
242 TRACE ("BFD_RELOC_386_RELATIVE");
243 return &elf_howto_table
[R_386_RELATIVE
];
245 case BFD_RELOC_386_GOTOFF
:
246 TRACE ("BFD_RELOC_386_GOTOFF");
247 return &elf_howto_table
[R_386_GOTOFF
];
249 case BFD_RELOC_386_GOTPC
:
250 TRACE ("BFD_RELOC_386_GOTPC");
251 return &elf_howto_table
[R_386_GOTPC
];
253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF
:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
256 return &elf_howto_table
[R_386_TLS_TPOFF
- R_386_ext_offset
];
258 case BFD_RELOC_386_TLS_IE
:
259 TRACE ("BFD_RELOC_386_TLS_IE");
260 return &elf_howto_table
[R_386_TLS_IE
- R_386_ext_offset
];
262 case BFD_RELOC_386_TLS_GOTIE
:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
264 return &elf_howto_table
[R_386_TLS_GOTIE
- R_386_ext_offset
];
266 case BFD_RELOC_386_TLS_LE
:
267 TRACE ("BFD_RELOC_386_TLS_LE");
268 return &elf_howto_table
[R_386_TLS_LE
- R_386_ext_offset
];
270 case BFD_RELOC_386_TLS_GD
:
271 TRACE ("BFD_RELOC_386_TLS_GD");
272 return &elf_howto_table
[R_386_TLS_GD
- R_386_ext_offset
];
274 case BFD_RELOC_386_TLS_LDM
:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
276 return &elf_howto_table
[R_386_TLS_LDM
- R_386_ext_offset
];
279 TRACE ("BFD_RELOC_16");
280 return &elf_howto_table
[R_386_16
- R_386_ext_offset
];
282 case BFD_RELOC_16_PCREL
:
283 TRACE ("BFD_RELOC_16_PCREL");
284 return &elf_howto_table
[R_386_PC16
- R_386_ext_offset
];
287 TRACE ("BFD_RELOC_8");
288 return &elf_howto_table
[R_386_8
- R_386_ext_offset
];
290 case BFD_RELOC_8_PCREL
:
291 TRACE ("BFD_RELOC_8_PCREL");
292 return &elf_howto_table
[R_386_PC8
- R_386_ext_offset
];
294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32
:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
297 return &elf_howto_table
[R_386_TLS_LDO_32
- R_386_tls_offset
];
299 case BFD_RELOC_386_TLS_IE_32
:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
301 return &elf_howto_table
[R_386_TLS_IE_32
- R_386_tls_offset
];
303 case BFD_RELOC_386_TLS_LE_32
:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
305 return &elf_howto_table
[R_386_TLS_LE_32
- R_386_tls_offset
];
307 case BFD_RELOC_386_TLS_DTPMOD32
:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
309 return &elf_howto_table
[R_386_TLS_DTPMOD32
- R_386_tls_offset
];
311 case BFD_RELOC_386_TLS_DTPOFF32
:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
313 return &elf_howto_table
[R_386_TLS_DTPOFF32
- R_386_tls_offset
];
315 case BFD_RELOC_386_TLS_TPOFF32
:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
317 return &elf_howto_table
[R_386_TLS_TPOFF32
- R_386_tls_offset
];
319 case BFD_RELOC_SIZE32
:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table
[R_386_SIZE32
- R_386_tls_offset
];
323 case BFD_RELOC_386_TLS_GOTDESC
:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table
[R_386_TLS_GOTDESC
- R_386_tls_offset
];
327 case BFD_RELOC_386_TLS_DESC_CALL
:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table
[R_386_TLS_DESC_CALL
- R_386_tls_offset
];
331 case BFD_RELOC_386_TLS_DESC
:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table
[R_386_TLS_DESC
- R_386_tls_offset
];
335 case BFD_RELOC_386_IRELATIVE
:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
337 return &elf_howto_table
[R_386_IRELATIVE
- R_386_tls_offset
];
339 case BFD_RELOC_386_GOT32X
:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table
[R_386_GOT32X
- R_386_tls_offset
];
343 case BFD_RELOC_VTABLE_INHERIT
:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
345 return &elf_howto_table
[R_386_GNU_VTINHERIT
- R_386_vt_offset
];
347 case BFD_RELOC_VTABLE_ENTRY
:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
349 return &elf_howto_table
[R_386_GNU_VTENTRY
- R_386_vt_offset
];
359 static reloc_howto_type
*
360 elf_i386_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
365 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
366 if (elf_howto_table
[i
].name
!= NULL
367 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
368 return &elf_howto_table
[i
];
373 static reloc_howto_type
*
374 elf_i386_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
378 if ((indx
= r_type
) >= R_386_standard
379 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
380 >= R_386_ext
- R_386_standard
)
381 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
382 >= R_386_ext2
- R_386_ext
)
383 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext2
384 >= R_386_vt
- R_386_ext2
))
386 /* xgettext:c-format */
387 _bfd_error_handler (_("%B: invalid relocation type %d"),
391 /* PR 17512: file: 0f67f69d. */
392 if (elf_howto_table
[indx
].type
!= r_type
)
394 return &elf_howto_table
[indx
];
398 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
400 Elf_Internal_Rela
*dst
)
402 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
403 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
406 /* Return whether a symbol name implies a local label. The UnixWare
407 2.1 cc generates temporary symbols that start with .X, so we
408 recognize them here. FIXME: do other SVR4 compilers also use .X?.
409 If so, we should move the .X recognition into
410 _bfd_elf_is_local_label_name. */
413 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
415 if (name
[0] == '.' && name
[1] == 'X')
418 return _bfd_elf_is_local_label_name (abfd
, name
);
421 /* Support for core dump NOTE sections. */
424 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
429 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
431 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
437 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
440 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
444 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
448 switch (note
->descsz
)
453 case 144: /* Linux/i386 */
455 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
458 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
468 /* Make a ".reg/999" section. */
469 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
470 size
, note
->descpos
+ offset
);
474 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
476 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
478 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
483 elf_tdata (abfd
)->core
->program
484 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
485 elf_tdata (abfd
)->core
->command
486 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
490 switch (note
->descsz
)
495 case 124: /* Linux/i386 elf_prpsinfo. */
496 elf_tdata (abfd
)->core
->pid
497 = bfd_get_32 (abfd
, note
->descdata
+ 12);
498 elf_tdata (abfd
)->core
->program
499 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
500 elf_tdata (abfd
)->core
->command
501 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
505 /* Note that for some reason, a spurious space is tacked
506 onto the end of the args in some (at least one anyway)
507 implementations, so strip it off if it exists. */
509 char *command
= elf_tdata (abfd
)->core
->command
;
510 int n
= strlen (command
);
512 if (0 < n
&& command
[n
- 1] == ' ')
513 command
[n
- 1] = '\0';
519 /* Functions for the i386 ELF linker.
521 In order to gain some understanding of code in this file without
522 knowing all the intricate details of the linker, note the
525 Functions named elf_i386_* are called by external routines, other
526 functions are only called locally. elf_i386_* functions appear
527 in this file more or less in the order in which they are called
528 from external routines. eg. elf_i386_check_relocs is called
529 early in the link process, elf_i386_finish_dynamic_sections is
530 one of the last functions. */
533 /* The name of the dynamic interpreter. This is put in the .interp
536 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
538 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
539 copying dynamic variables from a shared lib into an app's dynbss
540 section, and instead use a dynamic relocation to point into the
542 #define ELIMINATE_COPY_RELOCS 1
544 /* The size in bytes of an entry in the lazy procedure linkage table. */
546 #define LAZY_PLT_ENTRY_SIZE 16
548 /* The size in bytes of an entry in the non-lazy procedure linkage
551 #define NON_LAZY_PLT_ENTRY_SIZE 8
553 /* The first entry in an absolute lazy procedure linkage table looks
554 like this. See the SVR4 ABI i386 supplement to see how this works.
555 Will be padded to LAZY_PLT_ENTRY_SIZE with lazy_plt->plt0_pad_byte. */
557 static const bfd_byte elf_i386_lazy_plt0_entry
[12] =
559 0xff, 0x35, /* pushl contents of address */
560 0, 0, 0, 0, /* replaced with address of .got + 4. */
561 0xff, 0x25, /* jmp indirect */
562 0, 0, 0, 0 /* replaced with address of .got + 8. */
565 /* Subsequent entries in an absolute lazy procedure linkage table look
568 static const bfd_byte elf_i386_lazy_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
570 0xff, 0x25, /* jmp indirect */
571 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
572 0x68, /* pushl immediate */
573 0, 0, 0, 0, /* replaced with offset into relocation table. */
574 0xe9, /* jmp relative */
575 0, 0, 0, 0 /* replaced with offset to start of .plt. */
578 /* The first entry in a PIC lazy procedure linkage table look like
579 this. Will be padded to LAZY_PLT_ENTRY_SIZE with
580 lazy_plt->plt0_pad_byte. */
582 static const bfd_byte elf_i386_pic_lazy_plt0_entry
[12] =
584 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
585 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
588 /* Subsequent entries in a PIC lazy procedure linkage table look like
591 static const bfd_byte elf_i386_pic_lazy_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
593 0xff, 0xa3, /* jmp *offset(%ebx) */
594 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
595 0x68, /* pushl immediate */
596 0, 0, 0, 0, /* replaced with offset into relocation table. */
597 0xe9, /* jmp relative */
598 0, 0, 0, 0 /* replaced with offset to start of .plt. */
601 /* Entries in the non-lazy procedure linkage table look like this. */
603 static const bfd_byte elf_i386_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
605 0xff, 0x25, /* jmp indirect */
606 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
607 0x66, 0x90 /* xchg %ax,%ax */
610 /* Entries in the PIC non-lazy procedure linkage table look like
613 static const bfd_byte elf_i386_pic_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
615 0xff, 0xa3, /* jmp *offset(%ebx) */
616 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
617 0x66, 0x90 /* xchg %ax,%ax */
620 /* .eh_frame covering the lazy .plt section. */
622 static const bfd_byte elf_i386_eh_frame_lazy_plt
[] =
624 #define PLT_CIE_LENGTH 20
625 #define PLT_FDE_LENGTH 36
626 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
627 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
628 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
629 0, 0, 0, 0, /* CIE ID */
631 'z', 'R', 0, /* Augmentation string */
632 1, /* Code alignment factor */
633 0x7c, /* Data alignment factor */
634 8, /* Return address column */
635 1, /* Augmentation size */
636 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
637 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
638 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
639 DW_CFA_nop
, DW_CFA_nop
,
641 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
642 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
643 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
644 0, 0, 0, 0, /* .plt size goes here */
645 0, /* Augmentation size */
646 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
647 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
648 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
649 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
650 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
651 11, /* Block length */
652 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
653 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
654 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
655 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
656 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
659 /* .eh_frame covering the non-lazy .plt section. */
661 static const bfd_byte elf_i386_eh_frame_non_lazy_plt
[] =
663 #define PLT_GOT_FDE_LENGTH 16
664 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
665 0, 0, 0, 0, /* CIE ID */
667 'z', 'R', 0, /* Augmentation string */
668 1, /* Code alignment factor */
669 0x7c, /* Data alignment factor */
670 8, /* Return address column */
671 1, /* Augmentation size */
672 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
673 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
674 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
675 DW_CFA_nop
, DW_CFA_nop
,
677 PLT_GOT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
678 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
679 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
680 0, 0, 0, 0, /* non-lazy .plt size goes here */
681 0, /* Augmentation size */
682 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
685 struct elf_i386_lazy_plt_layout
687 /* The first entry in an absolute lazy procedure linkage table looks
689 const bfd_byte
*plt0_entry
;
690 unsigned int plt0_entry_size
;
692 /* Offsets into plt0_entry that are to be replaced with GOT[1] and
694 unsigned int plt0_got1_offset
;
695 unsigned int plt0_got2_offset
;
697 /* Later entries in an absolute lazy procedure linkage table look
699 const bfd_byte
*plt_entry
;
700 unsigned int plt_entry_size
;
702 /* Offsets into plt_entry that are to be replaced with... */
703 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
704 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
705 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
707 /* Offset into plt_entry where the initial value of the GOT entry
709 unsigned int plt_lazy_offset
;
711 /* The first entry in a PIC lazy procedure linkage table looks like
713 const bfd_byte
*pic_plt0_entry
;
715 /* Subsequent entries in a PIC lazy procedure linkage table look
717 const bfd_byte
*pic_plt_entry
;
719 /* .eh_frame covering the lazy .plt section. */
720 const bfd_byte
*eh_frame_plt
;
721 unsigned int eh_frame_plt_size
;
724 struct elf_i386_non_lazy_plt_layout
726 /* Entries in an absolute non-lazy procedure linkage table look like
728 const bfd_byte
*plt_entry
;
729 /* Entries in a PIC non-lazy procedure linkage table look like this. */
730 const bfd_byte
*pic_plt_entry
;
732 unsigned int plt_entry_size
;
734 /* Offsets into plt_entry that are to be replaced with... */
735 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
737 /* .eh_frame covering the non-lazy .plt section. */
738 const bfd_byte
*eh_frame_plt
;
739 unsigned int eh_frame_plt_size
;
742 struct elf_i386_plt_layout
744 /* The first entry in a lazy procedure linkage table looks like this. */
745 const bfd_byte
*plt0_entry
;
746 /* Entries in a procedure linkage table look like this. */
747 const bfd_byte
*plt_entry
;
748 unsigned int plt_entry_size
;
751 unsigned int has_plt0
;
753 /* Offsets into plt_entry that are to be replaced with... */
754 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
756 /* .eh_frame covering the .plt section. */
757 const bfd_byte
*eh_frame_plt
;
758 unsigned int eh_frame_plt_size
;
761 /* These are the standard parameters. */
762 static const struct elf_i386_lazy_plt_layout elf_i386_lazy_plt
=
764 elf_i386_lazy_plt0_entry
, /* plt0_entry */
765 sizeof (elf_i386_lazy_plt0_entry
), /* plt0_entry_size */
766 2, /* plt0_got1_offset */
767 8, /* plt0_got2_offset */
768 elf_i386_lazy_plt_entry
, /* plt_entry */
769 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
770 2, /* plt_got_offset */
771 7, /* plt_reloc_offset */
772 12, /* plt_plt_offset */
773 6, /* plt_lazy_offset */
774 elf_i386_pic_lazy_plt0_entry
, /* pic_plt0_entry */
775 elf_i386_pic_lazy_plt_entry
, /* pic_plt_entry */
776 elf_i386_eh_frame_lazy_plt
, /* eh_frame_plt */
777 sizeof (elf_i386_eh_frame_lazy_plt
) /* eh_frame_plt_size */
780 static const struct elf_i386_non_lazy_plt_layout elf_i386_non_lazy_plt
=
782 elf_i386_non_lazy_plt_entry
, /* plt_entry */
783 elf_i386_pic_non_lazy_plt_entry
, /* pic_plt_entry */
784 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
785 2, /* plt_got_offset */
786 elf_i386_eh_frame_non_lazy_plt
, /* eh_frame_plt */
787 sizeof (elf_i386_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
791 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
792 for the PLTResolve stub and then for each PLT entry. */
793 #define PLTRESOLVE_RELOCS_SHLIB 0
794 #define PLTRESOLVE_RELOCS 2
795 #define PLT_NON_JUMP_SLOT_RELOCS 2
797 /* Architecture-specific backend data for i386. */
799 struct elf_i386_backend_data
801 /* Value used to fill the unused bytes of the first PLT entry. */
802 bfd_byte plt0_pad_byte
;
813 #define get_elf_i386_backend_data(abfd) \
814 ((const struct elf_i386_backend_data *) \
815 get_elf_backend_data (abfd)->arch_data)
817 /* These are the standard parameters. */
818 static const struct elf_i386_backend_data elf_i386_arch_bed
=
820 0, /* plt0_pad_byte */
824 #define elf_backend_arch_data &elf_i386_arch_bed
826 /* Is a undefined weak symbol which is resolved to 0. Reference to an
827 undefined weak symbol is resolved to 0 when building executable if
829 1. Has non-GOT/non-PLT relocations in text section. Or
830 2. Has no GOT/PLT relocation.
832 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
833 ((EH)->elf.root.type == bfd_link_hash_undefweak \
834 && bfd_link_executable (INFO) \
835 && (elf_i386_hash_table (INFO)->interp == NULL \
837 || (EH)->has_non_got_reloc \
838 || !(INFO)->dynamic_undefined_weak))
840 /* i386 ELF linker hash entry. */
842 struct elf_i386_link_hash_entry
844 struct elf_link_hash_entry elf
;
846 /* Track dynamic relocs copied for this symbol. */
847 struct elf_dyn_relocs
*dyn_relocs
;
849 #define GOT_UNKNOWN 0
853 #define GOT_TLS_IE_POS 5
854 #define GOT_TLS_IE_NEG 6
855 #define GOT_TLS_IE_BOTH 7
856 #define GOT_TLS_GDESC 8
857 #define GOT_TLS_GD_BOTH_P(type) \
858 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
859 #define GOT_TLS_GD_P(type) \
860 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
861 #define GOT_TLS_GDESC_P(type) \
862 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
863 #define GOT_TLS_GD_ANY_P(type) \
864 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
865 unsigned char tls_type
;
867 /* Symbol is referenced by R_386_GOTOFF relocation. */
868 unsigned int gotoff_ref
: 1;
870 /* Symbol has GOT or PLT relocations. */
871 unsigned int has_got_reloc
: 1;
873 /* Symbol has non-GOT/non-PLT relocations in text sections. */
874 unsigned int has_non_got_reloc
: 1;
876 /* Don't call finish_dynamic_symbol on this symbol. */
877 unsigned int no_finish_dynamic_symbol
: 1;
879 /* 0: symbol isn't ___tls_get_addr.
880 1: symbol is ___tls_get_addr.
881 2: symbol is unknown. */
882 unsigned int tls_get_addr
: 2;
884 /* Reference count of C/C++ function pointer relocations in read-write
885 section which can be resolved at run-time. */
886 bfd_signed_vma func_pointer_refcount
;
888 /* Information about the GOT PLT entry. Filled when there are both
889 GOT and PLT relocations against the same function. */
890 union gotplt_union plt_got
;
892 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
893 starting at the end of the jump table. */
897 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
899 struct elf_i386_obj_tdata
901 struct elf_obj_tdata root
;
903 /* tls_type for each local got entry. */
904 char *local_got_tls_type
;
906 /* GOTPLT entries for TLS descriptors. */
907 bfd_vma
*local_tlsdesc_gotent
;
910 #define elf_i386_tdata(abfd) \
911 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
913 #define elf_i386_local_got_tls_type(abfd) \
914 (elf_i386_tdata (abfd)->local_got_tls_type)
916 #define elf_i386_local_tlsdesc_gotent(abfd) \
917 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
919 #define is_i386_elf(bfd) \
920 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
921 && elf_tdata (bfd) != NULL \
922 && elf_object_id (bfd) == I386_ELF_DATA)
925 elf_i386_mkobject (bfd
*abfd
)
927 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
931 /* i386 ELF linker hash table. */
933 struct elf_i386_link_hash_table
935 struct elf_link_hash_table elf
;
937 /* Short-cuts to get to dynamic linker sections. */
939 asection
*plt_eh_frame
;
941 asection
*plt_got_eh_frame
;
943 /* Parameters describing PLT generation. */
944 struct elf_i386_plt_layout plt
;
946 /* Parameters describing lazy PLT generation. */
947 const struct elf_i386_lazy_plt_layout
*lazy_plt
;
949 /* Parameters describing non-lazy PLT generation. */
950 const struct elf_i386_non_lazy_plt_layout
*non_lazy_plt
;
954 bfd_signed_vma refcount
;
958 /* The amount of space used by the reserved portion of the sgotplt
959 section, plus whatever space is used by the jump slots. */
960 bfd_vma sgotplt_jump_table_size
;
962 /* Small local sym cache. */
963 struct sym_cache sym_cache
;
965 /* _TLS_MODULE_BASE_ symbol. */
966 struct bfd_link_hash_entry
*tls_module_base
;
968 /* Used by local STT_GNU_IFUNC symbols. */
969 htab_t loc_hash_table
;
970 void * loc_hash_memory
;
972 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
975 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
976 bfd_vma next_tls_desc_index
;
978 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
979 bfd_vma next_jump_slot_index
;
981 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
982 bfd_vma next_irelative_index
;
984 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
985 to read-only sections. */
986 bfd_boolean readonly_dynrelocs_against_ifunc
;
989 /* Get the i386 ELF linker hash table from a link_info structure. */
991 #define elf_i386_hash_table(p) \
992 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
993 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
995 #define elf_i386_compute_jump_table_size(htab) \
996 ((htab)->elf.srelplt->reloc_count * 4)
998 /* Create an entry in an i386 ELF linker hash table. */
1000 static struct bfd_hash_entry
*
1001 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1002 struct bfd_hash_table
*table
,
1005 /* Allocate the structure if it has not already been allocated by a
1009 entry
= (struct bfd_hash_entry
*)
1010 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
1015 /* Call the allocation method of the superclass. */
1016 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
1019 struct elf_i386_link_hash_entry
*eh
;
1021 eh
= (struct elf_i386_link_hash_entry
*) entry
;
1022 eh
->dyn_relocs
= NULL
;
1023 eh
->tls_type
= GOT_UNKNOWN
;
1025 eh
->has_got_reloc
= 0;
1026 eh
->has_non_got_reloc
= 0;
1027 eh
->no_finish_dynamic_symbol
= 0;
1028 eh
->tls_get_addr
= 2;
1029 eh
->func_pointer_refcount
= 0;
1030 eh
->plt_got
.offset
= (bfd_vma
) -1;
1031 eh
->tlsdesc_got
= (bfd_vma
) -1;
1037 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
1038 for local symbol so that we can handle local STT_GNU_IFUNC symbols
1039 as global symbol. We reuse indx and dynstr_index for local symbol
1040 hash since they aren't used by global symbols in this backend. */
1043 elf_i386_local_htab_hash (const void *ptr
)
1045 struct elf_link_hash_entry
*h
1046 = (struct elf_link_hash_entry
*) ptr
;
1047 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
1050 /* Compare local hash entries. */
1053 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
1055 struct elf_link_hash_entry
*h1
1056 = (struct elf_link_hash_entry
*) ptr1
;
1057 struct elf_link_hash_entry
*h2
1058 = (struct elf_link_hash_entry
*) ptr2
;
1060 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
1063 /* Find and/or create a hash entry for local symbol. */
1065 static struct elf_link_hash_entry
*
1066 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
1067 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1070 struct elf_i386_link_hash_entry e
, *ret
;
1071 asection
*sec
= abfd
->sections
;
1072 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1073 ELF32_R_SYM (rel
->r_info
));
1076 e
.elf
.indx
= sec
->id
;
1077 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
1078 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1079 create
? INSERT
: NO_INSERT
);
1086 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
1090 ret
= (struct elf_i386_link_hash_entry
*)
1091 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1092 sizeof (struct elf_i386_link_hash_entry
));
1095 memset (ret
, 0, sizeof (*ret
));
1096 ret
->elf
.indx
= sec
->id
;
1097 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
1098 ret
->elf
.dynindx
= -1;
1099 ret
->func_pointer_refcount
= 0;
1100 ret
->plt_got
.offset
= (bfd_vma
) -1;
1106 /* Destroy an i386 ELF linker hash table. */
1109 elf_i386_link_hash_table_free (bfd
*obfd
)
1111 struct elf_i386_link_hash_table
*htab
1112 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1114 if (htab
->loc_hash_table
)
1115 htab_delete (htab
->loc_hash_table
);
1116 if (htab
->loc_hash_memory
)
1117 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1118 _bfd_elf_link_hash_table_free (obfd
);
1121 /* Create an i386 ELF linker hash table. */
1123 static struct bfd_link_hash_table
*
1124 elf_i386_link_hash_table_create (bfd
*abfd
)
1126 struct elf_i386_link_hash_table
*ret
;
1127 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1129 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1133 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1134 elf_i386_link_hash_newfunc
,
1135 sizeof (struct elf_i386_link_hash_entry
),
1142 ret
->loc_hash_table
= htab_try_create (1024,
1143 elf_i386_local_htab_hash
,
1144 elf_i386_local_htab_eq
,
1146 ret
->loc_hash_memory
= objalloc_create ();
1147 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1149 elf_i386_link_hash_table_free (abfd
);
1152 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1154 return &ret
->elf
.root
;
1157 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1160 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1161 struct elf_link_hash_entry
*dir
,
1162 struct elf_link_hash_entry
*ind
)
1164 struct elf_i386_link_hash_entry
*edir
, *eind
;
1166 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1167 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1169 if (eind
->dyn_relocs
!= NULL
)
1171 if (edir
->dyn_relocs
!= NULL
)
1173 struct elf_dyn_relocs
**pp
;
1174 struct elf_dyn_relocs
*p
;
1176 /* Add reloc counts against the indirect sym to the direct sym
1177 list. Merge any entries against the same section. */
1178 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1180 struct elf_dyn_relocs
*q
;
1182 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1183 if (q
->sec
== p
->sec
)
1185 q
->pc_count
+= p
->pc_count
;
1186 q
->count
+= p
->count
;
1193 *pp
= edir
->dyn_relocs
;
1196 edir
->dyn_relocs
= eind
->dyn_relocs
;
1197 eind
->dyn_relocs
= NULL
;
1200 if (ind
->root
.type
== bfd_link_hash_indirect
1201 && dir
->got
.refcount
<= 0)
1203 edir
->tls_type
= eind
->tls_type
;
1204 eind
->tls_type
= GOT_UNKNOWN
;
1207 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1208 generate a R_386_COPY reloc. */
1209 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1211 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1212 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1214 if (ELIMINATE_COPY_RELOCS
1215 && ind
->root
.type
!= bfd_link_hash_indirect
1216 && dir
->dynamic_adjusted
)
1218 /* If called to transfer flags for a weakdef during processing
1219 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1220 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1221 if (dir
->versioned
!= versioned_hidden
)
1222 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1223 dir
->ref_regular
|= ind
->ref_regular
;
1224 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1225 dir
->needs_plt
|= ind
->needs_plt
;
1226 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1230 if (eind
->func_pointer_refcount
> 0)
1232 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1233 eind
->func_pointer_refcount
= 0;
1236 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1240 /* Return TRUE if the TLS access code sequence support transition
1244 elf_i386_check_tls_transition (asection
*sec
,
1246 Elf_Internal_Shdr
*symtab_hdr
,
1247 struct elf_link_hash_entry
**sym_hashes
,
1248 unsigned int r_type
,
1249 const Elf_Internal_Rela
*rel
,
1250 const Elf_Internal_Rela
*relend
)
1252 unsigned int val
, type
, reg
;
1253 unsigned long r_symndx
;
1254 struct elf_link_hash_entry
*h
;
1257 bfd_boolean indirect_call
, tls_get_addr
;
1259 offset
= rel
->r_offset
;
1264 if (offset
< 2 || (rel
+ 1) >= relend
)
1267 indirect_call
= FALSE
;
1268 call
= contents
+ offset
+ 4;
1271 if (r_type
== R_386_TLS_GD
)
1273 /* Check transition from GD access model. Only
1274 leal foo@tlsgd(,%ebx,1), %eax
1275 call ___tls_get_addr@PLT
1277 leal foo@tlsgd(%ebx) %eax
1278 call ___tls_get_addr@PLT
1281 leal foo@tlsgd(%reg), %eax
1282 call *___tls_get_addr@GOT(%reg)
1283 which may be converted to
1284 addr32 call ___tls_get_addr
1285 can transit to different access model. */
1286 if ((offset
+ 10) > sec
->size
1287 || (type
!= 0x8d && type
!= 0x04))
1292 /* leal foo@tlsgd(,%ebx,1), %eax
1293 call ___tls_get_addr@PLT */
1297 if (*(call
- 7) != 0x8d
1305 leal foo@tlsgd(%ebx), %eax
1306 call ___tls_get_addr@PLT
1309 leal foo@tlsgd(%reg), %eax
1310 call *___tls_get_addr@GOT(%reg)
1311 which may be converted to
1312 addr32 call ___tls_get_addr
1314 %eax can't be used as the GOT base register since it
1315 is used to pass parameter to ___tls_get_addr. */
1317 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1320 indirect_call
= call
[0] == 0xff;
1321 if (!(reg
== 3 && call
[0] == 0xe8 && call
[5] == 0x90)
1322 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1324 && (call
[1] & 0xf8) == 0x90
1325 && (call
[1] & 0x7) == reg
))
1331 /* Check transition from LD access model. Only
1332 leal foo@tlsldm(%ebx), %eax
1333 call ___tls_get_addr@PLT
1335 leal foo@tlsldm(%reg), %eax
1336 call *___tls_get_addr@GOT(%reg)
1337 which may be converted to
1338 addr32 call ___tls_get_addr
1339 can transit to different access model. */
1340 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1343 /* %eax can't be used as the GOT base register since it is
1344 used to pass parameter to ___tls_get_addr. */
1346 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1349 indirect_call
= call
[0] == 0xff;
1350 if (!(reg
== 3 && call
[0] == 0xe8)
1351 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1353 && (call
[1] & 0xf8) == 0x90
1354 && (call
[1] & 0x7) == reg
))
1358 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1359 if (r_symndx
< symtab_hdr
->sh_info
)
1362 tls_get_addr
= FALSE
;
1363 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1364 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1366 struct elf_i386_link_hash_entry
*eh
1367 = (struct elf_i386_link_hash_entry
*) h
;
1368 tls_get_addr
= eh
->tls_get_addr
== 1;
1369 if (eh
->tls_get_addr
> 1)
1371 /* Use strncmp to check ___tls_get_addr since
1372 ___tls_get_addr may be versioned. */
1373 if (strncmp (h
->root
.root
.string
, "___tls_get_addr", 15)
1376 eh
->tls_get_addr
= 1;
1377 tls_get_addr
= TRUE
;
1380 eh
->tls_get_addr
= 0;
1386 else if (indirect_call
)
1387 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_GOT32X
);
1389 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1390 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
1393 /* Check transition from IE access model:
1394 movl foo@indntpoff(%rip), %eax
1395 movl foo@indntpoff(%rip), %reg
1396 addl foo@indntpoff(%rip), %reg
1399 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1402 /* Check "movl foo@tpoff(%rip), %eax" first. */
1403 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1410 /* Check movl|addl foo@tpoff(%rip), %reg. */
1411 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1412 return ((type
== 0x8b || type
== 0x03)
1413 && (val
& 0xc7) == 0x05);
1415 case R_386_TLS_GOTIE
:
1416 case R_386_TLS_IE_32
:
1417 /* Check transition from {IE_32,GOTIE} access model:
1418 subl foo@{tpoff,gontoff}(%reg1), %reg2
1419 movl foo@{tpoff,gontoff}(%reg1), %reg2
1420 addl foo@{tpoff,gontoff}(%reg1), %reg2
1423 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1426 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1427 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1430 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1431 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1433 case R_386_TLS_GOTDESC
:
1434 /* Check transition from GDesc access model:
1435 leal x@tlsdesc(%ebx), %eax
1437 Make sure it's a leal adding ebx to a 32-bit offset
1438 into any register, although it's probably almost always
1441 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1444 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1447 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1448 return (val
& 0xc7) == 0x83;
1450 case R_386_TLS_DESC_CALL
:
1451 /* Check transition from GDesc access model:
1452 call *x@tlsdesc(%eax)
1454 if (offset
+ 2 <= sec
->size
)
1456 /* Make sure that it's a call *x@tlsdesc(%eax). */
1457 call
= contents
+ offset
;
1458 return call
[0] == 0xff && call
[1] == 0x10;
1468 /* Return TRUE if the TLS access transition is OK or no transition
1469 will be performed. Update R_TYPE if there is a transition. */
1472 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1473 asection
*sec
, bfd_byte
*contents
,
1474 Elf_Internal_Shdr
*symtab_hdr
,
1475 struct elf_link_hash_entry
**sym_hashes
,
1476 unsigned int *r_type
, int tls_type
,
1477 const Elf_Internal_Rela
*rel
,
1478 const Elf_Internal_Rela
*relend
,
1479 struct elf_link_hash_entry
*h
,
1480 unsigned long r_symndx
,
1481 bfd_boolean from_relocate_section
)
1483 unsigned int from_type
= *r_type
;
1484 unsigned int to_type
= from_type
;
1485 bfd_boolean check
= TRUE
;
1487 /* Skip TLS transition for functions. */
1489 && (h
->type
== STT_FUNC
1490 || h
->type
== STT_GNU_IFUNC
))
1496 case R_386_TLS_GOTDESC
:
1497 case R_386_TLS_DESC_CALL
:
1498 case R_386_TLS_IE_32
:
1500 case R_386_TLS_GOTIE
:
1501 if (bfd_link_executable (info
))
1504 to_type
= R_386_TLS_LE_32
;
1505 else if (from_type
!= R_386_TLS_IE
1506 && from_type
!= R_386_TLS_GOTIE
)
1507 to_type
= R_386_TLS_IE_32
;
1510 /* When we are called from elf_i386_relocate_section, there may
1511 be additional transitions based on TLS_TYPE. */
1512 if (from_relocate_section
)
1514 unsigned int new_to_type
= to_type
;
1516 if (bfd_link_executable (info
)
1519 && (tls_type
& GOT_TLS_IE
))
1520 new_to_type
= R_386_TLS_LE_32
;
1522 if (to_type
== R_386_TLS_GD
1523 || to_type
== R_386_TLS_GOTDESC
1524 || to_type
== R_386_TLS_DESC_CALL
)
1526 if (tls_type
== GOT_TLS_IE_POS
)
1527 new_to_type
= R_386_TLS_GOTIE
;
1528 else if (tls_type
& GOT_TLS_IE
)
1529 new_to_type
= R_386_TLS_IE_32
;
1532 /* We checked the transition before when we were called from
1533 elf_i386_check_relocs. We only want to check the new
1534 transition which hasn't been checked before. */
1535 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1536 to_type
= new_to_type
;
1542 if (bfd_link_executable (info
))
1543 to_type
= R_386_TLS_LE_32
;
1550 /* Return TRUE if there is no transition. */
1551 if (from_type
== to_type
)
1554 /* Check if the transition can be performed. */
1556 && ! elf_i386_check_tls_transition (sec
, contents
,
1557 symtab_hdr
, sym_hashes
,
1558 from_type
, rel
, relend
))
1560 reloc_howto_type
*from
, *to
;
1563 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1564 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1567 name
= h
->root
.root
.string
;
1570 struct elf_i386_link_hash_table
*htab
;
1572 htab
= elf_i386_hash_table (info
);
1577 Elf_Internal_Sym
*isym
;
1579 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1581 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1586 /* xgettext:c-format */
1587 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1588 "in section `%A' failed"),
1589 abfd
, from
->name
, to
->name
, name
,
1590 (unsigned long) rel
->r_offset
, sec
);
1591 bfd_set_error (bfd_error_bad_value
);
1599 /* With the local symbol, foo, we convert
1600 mov foo@GOT[(%reg1)], %reg2
1602 lea foo[@GOTOFF(%reg1)], %reg2
1604 call/jmp *foo@GOT[(%reg)]
1606 nop call foo/jmp foo nop
1607 When PIC is false, convert
1608 test %reg1, foo@GOT[(%reg2)]
1612 binop foo@GOT[(%reg1)], %reg2
1615 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1620 elf_i386_convert_load_reloc (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
1622 Elf_Internal_Rela
*irel
,
1623 struct elf_link_hash_entry
*h
,
1624 bfd_boolean
*converted
,
1625 struct bfd_link_info
*link_info
)
1627 struct elf_i386_link_hash_table
*htab
;
1628 unsigned int opcode
;
1630 bfd_boolean baseless
;
1631 Elf_Internal_Sym
*isym
;
1632 unsigned int addend
;
1636 bfd_boolean to_reloc_32
;
1637 unsigned int r_type
;
1638 unsigned int r_symndx
;
1639 bfd_vma roff
= irel
->r_offset
;
1644 /* Addend for R_386_GOT32X relocations must be 0. */
1645 addend
= bfd_get_32 (abfd
, contents
+ roff
);
1649 htab
= elf_i386_hash_table (link_info
);
1650 is_pic
= bfd_link_pic (link_info
);
1652 r_type
= ELF32_R_TYPE (irel
->r_info
);
1653 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1655 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1656 baseless
= (modrm
& 0xc7) == 0x5;
1658 if (baseless
&& is_pic
)
1660 /* For PIC, disallow R_386_GOT32X without a base register
1661 since we don't know what the GOT base is. */
1666 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
1668 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1671 name
= h
->root
.root
.string
;
1674 /* xgettext:c-format */
1675 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base"
1676 " register can not be used when making a shared object"),
1681 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1683 /* Convert to R_386_32 if PIC is false or there is no base
1685 to_reloc_32
= !is_pic
|| baseless
;
1687 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1691 if (opcode
== 0x0ff)
1692 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1693 goto convert_branch
;
1695 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1696 "test %reg1, foo@GOT(%reg2)" and
1697 "binop foo@GOT[(%reg1)], %reg2". */
1701 /* Undefined weak symbol is only bound locally in executable
1702 and its reference is resolved as 0. */
1703 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
1704 elf_i386_hash_entry (h
)))
1708 /* No direct branch to 0 for PIC. */
1712 goto convert_branch
;
1716 /* We can convert load of address 0 to R_386_32. */
1724 /* We have "call/jmp *foo@GOT[(%reg)]". */
1725 if ((h
->root
.type
== bfd_link_hash_defined
1726 || h
->root
.type
== bfd_link_hash_defweak
)
1727 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1729 /* The function is locally defined. */
1731 /* Convert R_386_GOT32X to R_386_PC32. */
1732 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
1734 struct elf_i386_link_hash_entry
*eh
1735 = (struct elf_i386_link_hash_entry
*) h
;
1737 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1740 /* To support TLS optimization, always use addr32 prefix
1741 for "call *___tls_get_addr@GOT(%reg)". */
1742 if (eh
&& eh
->tls_get_addr
== 1)
1745 nop_offset
= irel
->r_offset
- 2;
1749 nop
= link_info
->call_nop_byte
;
1750 if (link_info
->call_nop_as_suffix
)
1752 nop_offset
= roff
+ 3;
1753 irel
->r_offset
-= 1;
1756 nop_offset
= roff
- 2;
1761 /* Convert to "jmp foo nop". */
1764 nop_offset
= roff
+ 3;
1765 irel
->r_offset
-= 1;
1768 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1769 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1770 /* When converting to PC-relative relocation, we
1771 need to adjust addend by -4. */
1772 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
1773 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
1780 /* We have "mov foo@GOT[(%re1g)], %reg2",
1781 "test %reg1, foo@GOT(%reg2)" and
1782 "binop foo@GOT[(%reg1)], %reg2".
1784 Avoid optimizing _DYNAMIC since ld.so may use its
1785 link-time address. */
1786 if (h
== htab
->elf
.hdynamic
)
1789 /* def_regular is set by an assignment in a linker script in
1790 bfd_elf_record_link_assignment. */
1792 || h
->root
.type
== bfd_link_hash_defined
1793 || h
->root
.type
== bfd_link_hash_defweak
)
1794 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1801 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1802 "mov $foo, %reg2" with R_386_32. */
1804 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1805 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1810 /* Convert "mov foo@GOT(%reg1), %reg2" to
1811 "lea foo@GOTOFF(%reg1), %reg2". */
1812 r_type
= R_386_GOTOFF
;
1818 /* Only R_386_32 is supported. */
1824 /* Convert "test %reg1, foo@GOT(%reg2)" to
1825 "test $foo, %reg1". */
1826 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1831 /* Convert "binop foo@GOT(%reg1), %reg2" to
1832 "binop $foo, %reg2". */
1834 | (modrm
& 0x38) >> 3
1838 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1842 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1843 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1852 /* Rename some of the generic section flags to better document how they
1854 #define need_convert_load sec_flg0
1855 #define check_relocs_failed sec_flg1
1857 /* Look through the relocs for a section during the first phase, and
1858 calculate needed space in the global offset table, procedure linkage
1859 table, and dynamic reloc sections. */
1862 elf_i386_check_relocs (bfd
*abfd
,
1863 struct bfd_link_info
*info
,
1865 const Elf_Internal_Rela
*relocs
)
1867 struct elf_i386_link_hash_table
*htab
;
1868 Elf_Internal_Shdr
*symtab_hdr
;
1869 struct elf_link_hash_entry
**sym_hashes
;
1870 const Elf_Internal_Rela
*rel
;
1871 const Elf_Internal_Rela
*rel_end
;
1875 if (bfd_link_relocatable (info
))
1878 /* Don't do anything special with non-loaded, non-alloced sections.
1879 In particular, any relocs in such sections should not affect GOT
1880 and PLT reference counting (ie. we don't allow them to create GOT
1881 or PLT entries), there's no possibility or desire to optimize TLS
1882 relocs, and there's not much point in propagating relocs to shared
1883 libs that the dynamic linker won't relocate. */
1884 if ((sec
->flags
& SEC_ALLOC
) == 0)
1887 BFD_ASSERT (is_i386_elf (abfd
));
1889 htab
= elf_i386_hash_table (info
);
1892 sec
->check_relocs_failed
= 1;
1896 /* Get the section contents. */
1897 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1898 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1899 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1901 sec
->check_relocs_failed
= 1;
1905 symtab_hdr
= &elf_symtab_hdr (abfd
);
1906 sym_hashes
= elf_sym_hashes (abfd
);
1910 rel_end
= relocs
+ sec
->reloc_count
;
1911 for (rel
= relocs
; rel
< rel_end
; rel
++)
1913 unsigned int r_type
;
1914 unsigned long r_symndx
;
1915 struct elf_link_hash_entry
*h
;
1916 struct elf_i386_link_hash_entry
*eh
;
1917 Elf_Internal_Sym
*isym
;
1919 bfd_boolean size_reloc
;
1921 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1922 r_type
= ELF32_R_TYPE (rel
->r_info
);
1924 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1926 /* xgettext:c-format */
1927 _bfd_error_handler (_("%B: bad symbol index: %d"),
1932 if (r_symndx
< symtab_hdr
->sh_info
)
1934 /* A local symbol. */
1935 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1940 /* Check relocation against local STT_GNU_IFUNC symbol. */
1941 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1943 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1947 /* Fake a STT_GNU_IFUNC symbol. */
1948 h
->type
= STT_GNU_IFUNC
;
1951 h
->forced_local
= 1;
1952 h
->root
.type
= bfd_link_hash_defined
;
1960 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1961 while (h
->root
.type
== bfd_link_hash_indirect
1962 || h
->root
.type
== bfd_link_hash_warning
)
1963 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1966 eh
= (struct elf_i386_link_hash_entry
*) h
;
1969 if (r_type
== R_386_GOTOFF
)
1972 /* It is referenced by a non-shared object. */
1974 h
->root
.non_ir_ref
= 1;
1976 if (h
->type
== STT_GNU_IFUNC
)
1977 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1978 |= elf_gnu_symbol_ifunc
;
1981 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1982 symtab_hdr
, sym_hashes
,
1983 &r_type
, GOT_UNKNOWN
,
1984 rel
, rel_end
, h
, r_symndx
, FALSE
))
1990 htab
->tls_ldm_got
.refcount
+= 1;
1994 /* This symbol requires a procedure linkage table entry. We
1995 actually build the entry in adjust_dynamic_symbol,
1996 because this might be a case of linking PIC code which is
1997 never referenced by a dynamic object, in which case we
1998 don't need to generate a procedure linkage table entry
2001 /* If this is a local symbol, we resolve it directly without
2002 creating a procedure linkage table entry. */
2006 eh
->has_got_reloc
= 1;
2008 h
->plt
.refcount
+= 1;
2015 case R_386_TLS_IE_32
:
2017 case R_386_TLS_GOTIE
:
2018 if (!bfd_link_executable (info
))
2019 info
->flags
|= DF_STATIC_TLS
;
2025 case R_386_TLS_GOTDESC
:
2026 case R_386_TLS_DESC_CALL
:
2027 /* This symbol requires a global offset table entry. */
2029 int tls_type
, old_tls_type
;
2036 tls_type
= GOT_NORMAL
;
2038 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
2039 case R_386_TLS_GOTDESC
:
2040 case R_386_TLS_DESC_CALL
:
2041 tls_type
= GOT_TLS_GDESC
; break;
2042 case R_386_TLS_IE_32
:
2043 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
2044 tls_type
= GOT_TLS_IE_NEG
;
2046 /* If this is a GD->IE transition, we may use either of
2047 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2048 tls_type
= GOT_TLS_IE
;
2051 case R_386_TLS_GOTIE
:
2052 tls_type
= GOT_TLS_IE_POS
; break;
2057 h
->got
.refcount
+= 1;
2058 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2062 bfd_signed_vma
*local_got_refcounts
;
2064 /* This is a global offset table entry for a local symbol. */
2065 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2066 if (local_got_refcounts
== NULL
)
2070 size
= symtab_hdr
->sh_info
;
2071 size
*= (sizeof (bfd_signed_vma
)
2072 + sizeof (bfd_vma
) + sizeof(char));
2073 local_got_refcounts
= (bfd_signed_vma
*)
2074 bfd_zalloc (abfd
, size
);
2075 if (local_got_refcounts
== NULL
)
2077 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2078 elf_i386_local_tlsdesc_gotent (abfd
)
2079 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2080 elf_i386_local_got_tls_type (abfd
)
2081 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2083 local_got_refcounts
[r_symndx
] += 1;
2084 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
2087 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
2088 tls_type
|= old_tls_type
;
2089 /* If a TLS symbol is accessed using IE at least once,
2090 there is no point to use dynamic model for it. */
2091 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2092 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2093 || (tls_type
& GOT_TLS_IE
) == 0))
2095 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
2096 tls_type
= old_tls_type
;
2097 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2098 && GOT_TLS_GD_ANY_P (tls_type
))
2099 tls_type
|= old_tls_type
;
2103 name
= h
->root
.root
.string
;
2105 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2108 /* xgettext:c-format */
2109 (_("%B: `%s' accessed both as normal and "
2110 "thread local symbol"),
2112 bfd_set_error (bfd_error_bad_value
);
2117 if (old_tls_type
!= tls_type
)
2120 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2122 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2130 if (r_type
!= R_386_TLS_IE
)
2133 eh
->has_got_reloc
= 1;
2138 case R_386_TLS_LE_32
:
2141 eh
->has_got_reloc
= 1;
2142 if (bfd_link_executable (info
))
2144 info
->flags
|= DF_STATIC_TLS
;
2149 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2150 eh
->has_non_got_reloc
= 1;
2152 /* We are called after all symbols have been resolved. Only
2153 relocation against STT_GNU_IFUNC symbol must go through
2156 && (bfd_link_executable (info
)
2157 || h
->type
== STT_GNU_IFUNC
))
2159 /* If this reloc is in a read-only section, we might
2160 need a copy reloc. We can't check reliably at this
2161 stage whether the section is read-only, as input
2162 sections have not yet been mapped to output sections.
2163 Tentatively set the flag for now, and correct in
2164 adjust_dynamic_symbol. */
2167 /* We may need a .plt entry if the symbol is a function
2168 defined in a shared lib or is a STT_GNU_IFUNC function
2169 referenced from the code or read-only section. */
2171 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2172 h
->plt
.refcount
+= 1;
2174 if (r_type
== R_386_PC32
)
2176 /* Since something like ".long foo - ." may be used
2177 as pointer, make sure that PLT is used if foo is
2178 a function defined in a shared library. */
2179 if ((sec
->flags
& SEC_CODE
) == 0)
2180 h
->pointer_equality_needed
= 1;
2181 else if (h
->type
== STT_GNU_IFUNC
2182 && bfd_link_pic (info
))
2185 name
= h
->root
.root
.string
;
2187 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2190 /* xgettext:c-format */
2191 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2193 bfd_set_error (bfd_error_bad_value
);
2199 h
->pointer_equality_needed
= 1;
2200 /* R_386_32 can be resolved at run-time. */
2201 if (r_type
== R_386_32
2202 && (sec
->flags
& SEC_READONLY
) == 0)
2203 eh
->func_pointer_refcount
+= 1;
2209 /* If we are creating a shared library, and this is a reloc
2210 against a global symbol, or a non PC relative reloc
2211 against a local symbol, then we need to copy the reloc
2212 into the shared library. However, if we are linking with
2213 -Bsymbolic, we do not need to copy a reloc against a
2214 global symbol which is defined in an object we are
2215 including in the link (i.e., DEF_REGULAR is set). At
2216 this point we have not seen all the input files, so it is
2217 possible that DEF_REGULAR is not set now but will be set
2218 later (it is never cleared). In case of a weak definition,
2219 DEF_REGULAR may be cleared later by a strong definition in
2220 a shared library. We account for that possibility below by
2221 storing information in the relocs_copied field of the hash
2222 table entry. A similar situation occurs when creating
2223 shared libraries and symbol visibility changes render the
2226 If on the other hand, we are creating an executable, we
2227 may need to keep relocations for symbols satisfied by a
2228 dynamic library if we manage to avoid copy relocs for the
2231 Generate dynamic pointer relocation against STT_GNU_IFUNC
2232 symbol in the non-code section. */
2233 if ((bfd_link_pic (info
)
2234 && (r_type
!= R_386_PC32
2236 && (! (bfd_link_pie (info
)
2237 || SYMBOLIC_BIND (info
, h
))
2238 || h
->root
.type
== bfd_link_hash_defweak
2239 || !h
->def_regular
))))
2241 && h
->type
== STT_GNU_IFUNC
2242 && r_type
== R_386_32
2243 && (sec
->flags
& SEC_CODE
) == 0)
2244 || (ELIMINATE_COPY_RELOCS
2245 && !bfd_link_pic (info
)
2247 && (h
->root
.type
== bfd_link_hash_defweak
2248 || !h
->def_regular
)))
2250 struct elf_dyn_relocs
*p
;
2251 struct elf_dyn_relocs
**head
;
2253 /* We must copy these reloc types into the output file.
2254 Create a reloc section in dynobj and make room for
2258 sreloc
= _bfd_elf_make_dynamic_reloc_section
2259 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2265 /* If this is a global symbol, we count the number of
2266 relocations we need for this symbol. */
2269 head
= &eh
->dyn_relocs
;
2273 /* Track dynamic relocs needed for local syms too.
2274 We really need local syms available to do this
2279 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2284 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2288 vpp
= &elf_section_data (s
)->local_dynrel
;
2289 head
= (struct elf_dyn_relocs
**)vpp
;
2293 if (p
== NULL
|| p
->sec
!= sec
)
2295 bfd_size_type amt
= sizeof *p
;
2296 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2308 /* Count size relocation as PC-relative relocation. */
2309 if (r_type
== R_386_PC32
|| size_reloc
)
2314 /* This relocation describes the C++ object vtable hierarchy.
2315 Reconstruct it for later use during GC. */
2316 case R_386_GNU_VTINHERIT
:
2317 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2321 /* This relocation describes which C++ vtable entries are actually
2322 used. Record for later use during GC. */
2323 case R_386_GNU_VTENTRY
:
2324 BFD_ASSERT (h
!= NULL
);
2326 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2334 if (r_type
== R_386_GOT32X
2335 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2336 sec
->need_convert_load
= 1;
2339 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2341 if (!info
->keep_memory
)
2345 /* Cache the section contents for elf_link_input_bfd. */
2346 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2353 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2355 sec
->check_relocs_failed
= 1;
2359 /* Return the section that should be marked against GC for a given
2363 elf_i386_gc_mark_hook (asection
*sec
,
2364 struct bfd_link_info
*info
,
2365 Elf_Internal_Rela
*rel
,
2366 struct elf_link_hash_entry
*h
,
2367 Elf_Internal_Sym
*sym
)
2370 switch (ELF32_R_TYPE (rel
->r_info
))
2372 case R_386_GNU_VTINHERIT
:
2373 case R_386_GNU_VTENTRY
:
2377 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2380 /* Remove undefined weak symbol from the dynamic symbol table if it
2381 is resolved to 0. */
2384 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2385 struct elf_link_hash_entry
*h
)
2387 if (h
->dynindx
!= -1
2388 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2389 elf_i386_hash_entry (h
)->has_got_reloc
,
2390 elf_i386_hash_entry (h
)))
2393 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2399 /* Adjust a symbol defined by a dynamic object and referenced by a
2400 regular object. The current definition is in some section of the
2401 dynamic object, but we're not including those sections. We have to
2402 change the definition to something the rest of the link can
2406 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2407 struct elf_link_hash_entry
*h
)
2409 struct elf_i386_link_hash_table
*htab
;
2411 struct elf_i386_link_hash_entry
*eh
;
2412 struct elf_dyn_relocs
*p
;
2414 /* STT_GNU_IFUNC symbol must go through PLT. */
2415 if (h
->type
== STT_GNU_IFUNC
)
2417 /* All local STT_GNU_IFUNC references must be treate as local
2418 calls via local PLT. */
2420 && SYMBOL_CALLS_LOCAL (info
, h
))
2422 bfd_size_type pc_count
= 0, count
= 0;
2423 struct elf_dyn_relocs
**pp
;
2425 eh
= (struct elf_i386_link_hash_entry
*) h
;
2426 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2428 pc_count
+= p
->pc_count
;
2429 p
->count
-= p
->pc_count
;
2438 if (pc_count
|| count
)
2443 /* Increment PLT reference count only for PC-relative
2446 if (h
->plt
.refcount
<= 0)
2447 h
->plt
.refcount
= 1;
2449 h
->plt
.refcount
+= 1;
2454 if (h
->plt
.refcount
<= 0)
2456 h
->plt
.offset
= (bfd_vma
) -1;
2462 /* If this is a function, put it in the procedure linkage table. We
2463 will fill in the contents of the procedure linkage table later,
2464 when we know the address of the .got section. */
2465 if (h
->type
== STT_FUNC
2468 if (h
->plt
.refcount
<= 0
2469 || SYMBOL_CALLS_LOCAL (info
, h
)
2470 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2471 && h
->root
.type
== bfd_link_hash_undefweak
))
2473 /* This case can occur if we saw a PLT32 reloc in an input
2474 file, but the symbol was never referred to by a dynamic
2475 object, or if all references were garbage collected. In
2476 such a case, we don't actually need to build a procedure
2477 linkage table, and we can just do a PC32 reloc instead. */
2478 h
->plt
.offset
= (bfd_vma
) -1;
2485 /* It's possible that we incorrectly decided a .plt reloc was
2486 needed for an R_386_PC32 reloc to a non-function sym in
2487 check_relocs. We can't decide accurately between function and
2488 non-function syms in check-relocs; Objects loaded later in
2489 the link may change h->type. So fix it now. */
2490 h
->plt
.offset
= (bfd_vma
) -1;
2492 /* If this is a weak symbol, and there is a real definition, the
2493 processor independent code will have arranged for us to see the
2494 real definition first, and we can just use the same value. */
2495 if (h
->u
.weakdef
!= NULL
)
2497 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2498 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2499 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2500 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2501 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2502 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2506 /* This is a reference to a symbol defined by a dynamic object which
2507 is not a function. */
2509 /* If we are creating a shared library, we must presume that the
2510 only references to the symbol are via the global offset table.
2511 For such cases we need not do anything here; the relocations will
2512 be handled correctly by relocate_section. */
2513 if (!bfd_link_executable (info
))
2516 /* If there are no references to this symbol that do not use the
2517 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2519 eh
= (struct elf_i386_link_hash_entry
*) h
;
2520 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2523 /* If -z nocopyreloc was given, we won't generate them either. */
2524 if (info
->nocopyreloc
)
2530 htab
= elf_i386_hash_table (info
);
2534 /* If there aren't any dynamic relocs in read-only sections nor
2535 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2536 avoid the copy reloc. This doesn't work on VxWorks, where we can
2537 not have dynamic relocations (other than copy and jump slot
2538 relocations) in an executable. */
2539 if (ELIMINATE_COPY_RELOCS
2541 && get_elf_i386_backend_data (info
->output_bfd
)->os
!= is_vxworks
)
2543 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2545 s
= p
->sec
->output_section
;
2546 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2557 /* We must allocate the symbol in our .dynbss section, which will
2558 become part of the .bss section of the executable. There will be
2559 an entry for this symbol in the .dynsym section. The dynamic
2560 object will contain position independent code, so all references
2561 from the dynamic object to this symbol will go through the global
2562 offset table. The dynamic linker will use the .dynsym entry to
2563 determine the address it must put in the global offset table, so
2564 both the dynamic object and the regular object will refer to the
2565 same memory location for the variable. */
2567 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2568 copy the initial value out of the dynamic object and into the
2569 runtime process image. */
2570 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2572 s
= htab
->elf
.sdynrelro
;
2573 srel
= htab
->elf
.sreldynrelro
;
2577 s
= htab
->elf
.sdynbss
;
2578 srel
= htab
->elf
.srelbss
;
2580 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2582 srel
->size
+= sizeof (Elf32_External_Rel
);
2586 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2589 /* Allocate space in .plt, .got and associated reloc sections for
2593 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2595 struct bfd_link_info
*info
;
2596 struct elf_i386_link_hash_table
*htab
;
2597 struct elf_i386_link_hash_entry
*eh
;
2598 struct elf_dyn_relocs
*p
;
2599 unsigned plt_entry_size
;
2600 bfd_boolean resolved_to_zero
;
2601 const struct elf_i386_backend_data
*bed
;
2603 if (h
->root
.type
== bfd_link_hash_indirect
)
2606 eh
= (struct elf_i386_link_hash_entry
*) h
;
2608 info
= (struct bfd_link_info
*) inf
;
2609 htab
= elf_i386_hash_table (info
);
2613 bed
= get_elf_i386_backend_data (info
->output_bfd
);
2615 plt_entry_size
= htab
->plt
.plt_entry_size
;
2617 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2621 /* Clear the reference count of function pointer relocations if
2622 symbol isn't a normal function. */
2623 if (h
->type
!= STT_FUNC
)
2624 eh
->func_pointer_refcount
= 0;
2626 /* We can't use the GOT PLT if pointer equality is needed since
2627 finish_dynamic_symbol won't clear symbol value and the dynamic
2628 linker won't update the GOT slot. We will get into an infinite
2629 loop at run-time. */
2630 if (htab
->plt_got
!= NULL
2631 && h
->type
!= STT_GNU_IFUNC
2632 && !h
->pointer_equality_needed
2633 && h
->plt
.refcount
> 0
2634 && h
->got
.refcount
> 0)
2636 /* Don't use the regular PLT if there are both GOT and GOTPLT
2638 h
->plt
.offset
= (bfd_vma
) -1;
2640 /* Use the GOT PLT. */
2641 eh
->plt_got
.refcount
= 1;
2644 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2645 here if it is defined and referenced in a non-shared object. */
2646 if (h
->type
== STT_GNU_IFUNC
2648 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2649 &htab
->readonly_dynrelocs_against_ifunc
,
2651 (htab
->plt
.has_plt0
*
2654 /* Don't create the PLT entry if there are only function pointer
2655 relocations which can be resolved at run-time. */
2656 else if (htab
->elf
.dynamic_sections_created
2657 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2658 || eh
->plt_got
.refcount
> 0))
2660 bfd_boolean use_plt_got
;
2662 /* Clear the reference count of function pointer relocations
2664 eh
->func_pointer_refcount
= 0;
2666 if (htab
->plt_got
!= NULL
2667 && (info
->flags
& DF_BIND_NOW
)
2668 && !h
->pointer_equality_needed
)
2670 /* Don't use the regular PLT for DF_BIND_NOW. */
2671 h
->plt
.offset
= (bfd_vma
) -1;
2673 /* Use the GOT PLT. */
2674 h
->got
.refcount
= 1;
2675 eh
->plt_got
.refcount
= 1;
2678 use_plt_got
= eh
->plt_got
.refcount
> 0;
2680 /* Make sure this symbol is output as a dynamic symbol.
2681 Undefined weak syms won't yet be marked as dynamic. */
2682 if (h
->dynindx
== -1
2684 && !resolved_to_zero
2685 && h
->root
.type
== bfd_link_hash_undefweak
)
2687 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2691 if (bfd_link_pic (info
)
2692 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2694 asection
*s
= htab
->elf
.splt
;
2695 asection
*got_s
= htab
->plt_got
;
2697 /* If this is the first .plt entry, make room for the special
2698 first entry. The .plt section is used by prelink to undo
2699 prelinking for dynamic relocations. */
2701 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
2704 eh
->plt_got
.offset
= got_s
->size
;
2706 h
->plt
.offset
= s
->size
;
2708 /* If this symbol is not defined in a regular file, and we are
2709 not generating a shared library, then set the symbol to this
2710 location in the .plt. This is required to make function
2711 pointers compare as equal between the normal executable and
2712 the shared library. */
2713 if (! bfd_link_pic (info
)
2718 /* We need to make a call to the entry of the GOT PLT
2719 instead of regular PLT entry. */
2720 h
->root
.u
.def
.section
= got_s
;
2721 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2725 h
->root
.u
.def
.section
= s
;
2726 h
->root
.u
.def
.value
= h
->plt
.offset
;
2730 /* Make room for this entry. */
2732 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
2735 s
->size
+= plt_entry_size
;
2737 /* We also need to make an entry in the .got.plt section,
2738 which will be placed in the .got section by the linker
2740 htab
->elf
.sgotplt
->size
+= 4;
2742 /* There should be no PLT relocation against resolved
2743 undefined weak symbol in executable. */
2744 if (!resolved_to_zero
)
2746 /* We also need to make an entry in the .rel.plt
2748 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2749 htab
->elf
.srelplt
->reloc_count
++;
2753 if (bed
->os
== is_vxworks
&& !bfd_link_pic (info
))
2755 /* VxWorks has a second set of relocations for each PLT entry
2756 in executables. They go in a separate relocation section,
2757 which is processed by the kernel loader. */
2759 /* There are two relocations for the initial PLT entry: an
2760 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2761 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2763 if (h
->plt
.offset
== plt_entry_size
)
2764 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2766 /* There are two extra relocations for each subsequent PLT entry:
2767 an R_386_32 relocation for the GOT entry, and an R_386_32
2768 relocation for the PLT entry. */
2770 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2775 eh
->plt_got
.offset
= (bfd_vma
) -1;
2776 h
->plt
.offset
= (bfd_vma
) -1;
2782 eh
->plt_got
.offset
= (bfd_vma
) -1;
2783 h
->plt
.offset
= (bfd_vma
) -1;
2787 eh
->tlsdesc_got
= (bfd_vma
) -1;
2789 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2790 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2791 if (h
->got
.refcount
> 0
2792 && bfd_link_executable (info
)
2794 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2795 h
->got
.offset
= (bfd_vma
) -1;
2796 else if (h
->got
.refcount
> 0)
2800 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2802 /* Make sure this symbol is output as a dynamic symbol.
2803 Undefined weak syms won't yet be marked as dynamic. */
2804 if (h
->dynindx
== -1
2806 && !resolved_to_zero
2807 && h
->root
.type
== bfd_link_hash_undefweak
)
2809 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2814 if (GOT_TLS_GDESC_P (tls_type
))
2816 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2817 - elf_i386_compute_jump_table_size (htab
);
2818 htab
->elf
.sgotplt
->size
+= 8;
2819 h
->got
.offset
= (bfd_vma
) -2;
2821 if (! GOT_TLS_GDESC_P (tls_type
)
2822 || GOT_TLS_GD_P (tls_type
))
2824 h
->got
.offset
= s
->size
;
2826 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2827 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2830 dyn
= htab
->elf
.dynamic_sections_created
;
2831 /* R_386_TLS_IE_32 needs one dynamic relocation,
2832 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2833 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2834 need two), R_386_TLS_GD needs one if local symbol and two if
2835 global. No dynamic relocation against resolved undefined weak
2836 symbol in executable. */
2837 if (tls_type
== GOT_TLS_IE_BOTH
)
2838 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2839 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2840 || (tls_type
& GOT_TLS_IE
))
2841 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2842 else if (GOT_TLS_GD_P (tls_type
))
2843 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2844 else if (! GOT_TLS_GDESC_P (tls_type
)
2845 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2846 && !resolved_to_zero
)
2847 || h
->root
.type
!= bfd_link_hash_undefweak
)
2848 && (bfd_link_pic (info
)
2849 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2850 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2851 if (GOT_TLS_GDESC_P (tls_type
))
2852 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2855 h
->got
.offset
= (bfd_vma
) -1;
2857 if (eh
->dyn_relocs
== NULL
)
2860 /* In the shared -Bsymbolic case, discard space allocated for
2861 dynamic pc-relative relocs against symbols which turn out to be
2862 defined in regular objects. For the normal shared case, discard
2863 space for pc-relative relocs that have become local due to symbol
2864 visibility changes. */
2866 if (bfd_link_pic (info
))
2868 /* The only reloc that uses pc_count is R_386_PC32, which will
2869 appear on a call or on something like ".long foo - .". We
2870 want calls to protected symbols to resolve directly to the
2871 function rather than going via the plt. If people want
2872 function pointer comparisons to work as expected then they
2873 should avoid writing assembly like ".long foo - .". */
2874 if (SYMBOL_CALLS_LOCAL (info
, h
))
2876 struct elf_dyn_relocs
**pp
;
2878 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2880 p
->count
-= p
->pc_count
;
2889 if (bed
->os
== is_vxworks
)
2891 struct elf_dyn_relocs
**pp
;
2892 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2894 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2901 /* Also discard relocs on undefined weak syms with non-default
2902 visibility or in PIE. */
2903 if (eh
->dyn_relocs
!= NULL
2904 && h
->root
.type
== bfd_link_hash_undefweak
)
2906 /* Undefined weak symbol is never bound locally in shared
2908 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2909 || resolved_to_zero
)
2913 /* Keep dynamic non-GOT/non-PLT relocation so that we
2914 can branch to 0 without PLT. */
2915 struct elf_dyn_relocs
**pp
;
2917 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2918 if (p
->pc_count
== 0)
2922 /* Remove non-R_386_PC32 relocation. */
2923 p
->count
= p
->pc_count
;
2927 if (eh
->dyn_relocs
!= NULL
)
2929 /* Make sure undefined weak symbols are output
2930 as dynamic symbols in PIEs for dynamic non-GOT
2931 non-PLT reloations. */
2932 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2937 eh
->dyn_relocs
= NULL
;
2939 else if (h
->dynindx
== -1
2940 && !h
->forced_local
)
2942 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2947 else if (ELIMINATE_COPY_RELOCS
)
2949 /* For the non-shared case, discard space for relocs against
2950 symbols which turn out to need copy relocs or are not
2951 dynamic. Keep dynamic relocations for run-time function
2952 pointer initialization. */
2954 if ((!h
->non_got_ref
2955 || eh
->func_pointer_refcount
> 0
2956 || (h
->root
.type
== bfd_link_hash_undefweak
2957 && !resolved_to_zero
))
2960 || (htab
->elf
.dynamic_sections_created
2961 && (h
->root
.type
== bfd_link_hash_undefweak
2962 || h
->root
.type
== bfd_link_hash_undefined
))))
2964 /* Make sure this symbol is output as a dynamic symbol.
2965 Undefined weak syms won't yet be marked as dynamic. */
2966 if (h
->dynindx
== -1
2968 && !resolved_to_zero
2969 && h
->root
.type
== bfd_link_hash_undefweak
)
2971 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2975 /* If that succeeded, we know we'll be keeping all the
2977 if (h
->dynindx
!= -1)
2981 eh
->dyn_relocs
= NULL
;
2982 eh
->func_pointer_refcount
= 0;
2987 /* Finally, allocate space. */
2988 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2992 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2994 BFD_ASSERT (sreloc
!= NULL
);
2995 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3001 /* Allocate space in .plt, .got and associated reloc sections for
3002 local dynamic relocs. */
3005 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
3007 struct elf_link_hash_entry
*h
3008 = (struct elf_link_hash_entry
*) *slot
;
3010 if (h
->type
!= STT_GNU_IFUNC
3014 || h
->root
.type
!= bfd_link_hash_defined
)
3017 return elf_i386_allocate_dynrelocs (h
, inf
);
3020 /* Find any dynamic relocs that apply to read-only sections. */
3023 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3025 struct elf_i386_link_hash_entry
*eh
;
3026 struct elf_dyn_relocs
*p
;
3028 /* Skip local IFUNC symbols. */
3029 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3032 eh
= (struct elf_i386_link_hash_entry
*) h
;
3033 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3035 asection
*s
= p
->sec
->output_section
;
3037 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3039 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3041 info
->flags
|= DF_TEXTREL
;
3043 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3044 || info
->error_textrel
)
3045 /* xgettext:c-format */
3046 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3047 p
->sec
->owner
, h
->root
.root
.string
,
3050 /* Not an error, just cut short the traversal. */
3057 /* Convert load via the GOT slot to load immediate. */
3060 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
3061 struct bfd_link_info
*link_info
)
3063 struct elf_i386_link_hash_table
*htab
;
3064 Elf_Internal_Shdr
*symtab_hdr
;
3065 Elf_Internal_Rela
*internal_relocs
;
3066 Elf_Internal_Rela
*irel
, *irelend
;
3068 bfd_boolean changed
;
3069 bfd_signed_vma
*local_got_refcounts
;
3071 /* Don't even try to convert non-ELF outputs. */
3072 if (!is_elf_hash_table (link_info
->hash
))
3075 /* Nothing to do if there is no need or no output. */
3076 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3077 || sec
->need_convert_load
== 0
3078 || bfd_is_abs_section (sec
->output_section
))
3081 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3083 /* Load the relocations for this section. */
3084 internal_relocs
= (_bfd_elf_link_read_relocs
3085 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3086 link_info
->keep_memory
));
3087 if (internal_relocs
== NULL
)
3091 htab
= elf_i386_hash_table (link_info
);
3092 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3094 /* Get the section contents. */
3095 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3096 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3099 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3103 irelend
= internal_relocs
+ sec
->reloc_count
;
3104 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3106 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3107 unsigned int r_symndx
;
3108 struct elf_link_hash_entry
*h
;
3109 bfd_boolean converted
;
3111 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3112 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3113 if (r_type
!= R_386_GOT32X
)
3116 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3117 if (r_symndx
< symtab_hdr
->sh_info
)
3118 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3119 (const Elf_Internal_Rela
*) irel
,
3123 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3124 while (h
->root
.type
== bfd_link_hash_indirect
3125 || h
->root
.type
== bfd_link_hash_warning
)
3126 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3129 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3130 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3134 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3135 irel
, h
, &converted
, link_info
))
3140 changed
= converted
;
3143 if (h
->got
.refcount
> 0)
3144 h
->got
.refcount
-= 1;
3148 if (local_got_refcounts
!= NULL
3149 && local_got_refcounts
[r_symndx
] > 0)
3150 local_got_refcounts
[r_symndx
] -= 1;
3155 if (contents
!= NULL
3156 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3158 if (!changed
&& !link_info
->keep_memory
)
3162 /* Cache the section contents for elf_link_input_bfd. */
3163 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3167 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3170 free (internal_relocs
);
3172 elf_section_data (sec
)->relocs
= internal_relocs
;
3178 if (contents
!= NULL
3179 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3181 if (internal_relocs
!= NULL
3182 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3183 free (internal_relocs
);
3187 /* Set the sizes of the dynamic sections. */
3190 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3192 struct elf_i386_link_hash_table
*htab
;
3198 htab
= elf_i386_hash_table (info
);
3201 dynobj
= htab
->elf
.dynobj
;
3205 /* Set up .got offsets for local syms, and space for local dynamic
3207 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3209 bfd_signed_vma
*local_got
;
3210 bfd_signed_vma
*end_local_got
;
3211 char *local_tls_type
;
3212 bfd_vma
*local_tlsdesc_gotent
;
3213 bfd_size_type locsymcount
;
3214 Elf_Internal_Shdr
*symtab_hdr
;
3217 if (! is_i386_elf (ibfd
))
3220 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3222 struct elf_dyn_relocs
*p
;
3224 if (!elf_i386_convert_load (ibfd
, s
, info
))
3227 for (p
= ((struct elf_dyn_relocs
*)
3228 elf_section_data (s
)->local_dynrel
);
3232 if (!bfd_is_abs_section (p
->sec
)
3233 && bfd_is_abs_section (p
->sec
->output_section
))
3235 /* Input section has been discarded, either because
3236 it is a copy of a linkonce section or due to
3237 linker script /DISCARD/, so we'll be discarding
3240 else if ((get_elf_i386_backend_data (output_bfd
)->os
3242 && strcmp (p
->sec
->output_section
->name
,
3245 /* Relocations in vxworks .tls_vars sections are
3246 handled specially by the loader. */
3248 else if (p
->count
!= 0)
3250 srel
= elf_section_data (p
->sec
)->sreloc
;
3251 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3252 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3253 && (info
->flags
& DF_TEXTREL
) == 0)
3255 info
->flags
|= DF_TEXTREL
;
3256 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3257 || info
->error_textrel
)
3258 /* xgettext:c-format */
3259 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3260 p
->sec
->owner
, p
->sec
);
3266 local_got
= elf_local_got_refcounts (ibfd
);
3270 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3271 locsymcount
= symtab_hdr
->sh_info
;
3272 end_local_got
= local_got
+ locsymcount
;
3273 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3274 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3276 srel
= htab
->elf
.srelgot
;
3277 for (; local_got
< end_local_got
;
3278 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3280 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3283 if (GOT_TLS_GDESC_P (*local_tls_type
))
3285 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3286 - elf_i386_compute_jump_table_size (htab
);
3287 htab
->elf
.sgotplt
->size
+= 8;
3288 *local_got
= (bfd_vma
) -2;
3290 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3291 || GOT_TLS_GD_P (*local_tls_type
))
3293 *local_got
= s
->size
;
3295 if (GOT_TLS_GD_P (*local_tls_type
)
3296 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3299 if (bfd_link_pic (info
)
3300 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3301 || (*local_tls_type
& GOT_TLS_IE
))
3303 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3304 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3305 else if (GOT_TLS_GD_P (*local_tls_type
)
3306 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3307 srel
->size
+= sizeof (Elf32_External_Rel
);
3308 if (GOT_TLS_GDESC_P (*local_tls_type
))
3309 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3313 *local_got
= (bfd_vma
) -1;
3317 if (htab
->tls_ldm_got
.refcount
> 0)
3319 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3321 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3322 htab
->elf
.sgot
->size
+= 8;
3323 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3326 htab
->tls_ldm_got
.offset
= -1;
3328 /* Allocate global sym .plt and .got entries, and space for global
3329 sym dynamic relocs. */
3330 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3332 /* Allocate .plt and .got entries, and space for local symbols. */
3333 htab_traverse (htab
->loc_hash_table
,
3334 elf_i386_allocate_local_dynrelocs
,
3337 /* For every jump slot reserved in the sgotplt, reloc_count is
3338 incremented. However, when we reserve space for TLS descriptors,
3339 it's not incremented, so in order to compute the space reserved
3340 for them, it suffices to multiply the reloc count by the jump
3343 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3344 so that R_386_IRELATIVE entries come last. */
3345 if (htab
->elf
.srelplt
)
3347 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3348 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3349 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3351 else if (htab
->elf
.irelplt
)
3352 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3355 if (htab
->elf
.sgotplt
)
3357 /* Don't allocate .got.plt section if there are no GOT nor PLT
3358 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3359 if ((htab
->elf
.hgot
== NULL
3360 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3361 && (htab
->elf
.sgotplt
->size
3362 == get_elf_backend_data (output_bfd
)->got_header_size
)
3363 && (htab
->elf
.splt
== NULL
3364 || htab
->elf
.splt
->size
== 0)
3365 && (htab
->elf
.sgot
== NULL
3366 || htab
->elf
.sgot
->size
== 0)
3367 && (htab
->elf
.iplt
== NULL
3368 || htab
->elf
.iplt
->size
== 0)
3369 && (htab
->elf
.igotplt
== NULL
3370 || htab
->elf
.igotplt
->size
== 0))
3371 htab
->elf
.sgotplt
->size
= 0;
3374 if (_bfd_elf_eh_frame_present (info
))
3376 if (htab
->plt_eh_frame
!= NULL
3377 && htab
->elf
.splt
!= NULL
3378 && htab
->elf
.splt
->size
!= 0
3379 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
3380 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
3382 if (htab
->plt_got_eh_frame
!= NULL
3383 && htab
->plt_got
!= NULL
3384 && htab
->plt_got
->size
!= 0
3385 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
3386 htab
->plt_got_eh_frame
->size
3387 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3390 /* We now have determined the sizes of the various dynamic sections.
3391 Allocate memory for them. */
3393 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3395 bfd_boolean strip_section
= TRUE
;
3397 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3400 if (s
== htab
->elf
.splt
3401 || s
== htab
->elf
.sgot
)
3403 /* Strip this section if we don't need it; see the
3405 /* We'd like to strip these sections if they aren't needed, but if
3406 we've exported dynamic symbols from them we must leave them.
3407 It's too late to tell BFD to get rid of the symbols. */
3409 if (htab
->elf
.hplt
!= NULL
)
3410 strip_section
= FALSE
;
3412 else if (s
== htab
->elf
.sgotplt
3413 || s
== htab
->elf
.iplt
3414 || s
== htab
->elf
.igotplt
3415 || s
== htab
->plt_got
3416 || s
== htab
->plt_eh_frame
3417 || s
== htab
->plt_got_eh_frame
3418 || s
== htab
->elf
.sdynbss
3419 || s
== htab
->elf
.sdynrelro
)
3421 /* Strip these too. */
3423 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3426 && s
!= htab
->elf
.srelplt
3427 && s
!= htab
->srelplt2
)
3430 /* We use the reloc_count field as a counter if we need
3431 to copy relocs into the output file. */
3436 /* It's not one of our sections, so don't allocate space. */
3442 /* If we don't need this section, strip it from the
3443 output file. This is mostly to handle .rel.bss and
3444 .rel.plt. We must create both sections in
3445 create_dynamic_sections, because they must be created
3446 before the linker maps input sections to output
3447 sections. The linker does that before
3448 adjust_dynamic_symbol is called, and it is that
3449 function which decides whether anything needs to go
3450 into these sections. */
3452 s
->flags
|= SEC_EXCLUDE
;
3456 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3459 /* Allocate memory for the section contents. We use bfd_zalloc
3460 here in case unused entries are not reclaimed before the
3461 section's contents are written out. This should not happen,
3462 but this way if it does, we get a R_386_NONE reloc instead
3464 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3465 if (s
->contents
== NULL
)
3469 if (htab
->plt_eh_frame
!= NULL
3470 && htab
->plt_eh_frame
->contents
!= NULL
)
3472 memcpy (htab
->plt_eh_frame
->contents
,
3473 htab
->plt
.eh_frame_plt
,
3474 htab
->plt_eh_frame
->size
);
3475 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3476 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3479 if (htab
->plt_got_eh_frame
!= NULL
3480 && htab
->plt_got_eh_frame
->contents
!= NULL
)
3482 memcpy (htab
->plt_got_eh_frame
->contents
,
3483 htab
->non_lazy_plt
->eh_frame_plt
,
3484 htab
->plt_got_eh_frame
->size
);
3485 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
3486 (htab
->plt_got_eh_frame
->contents
3487 + PLT_FDE_LEN_OFFSET
));
3490 if (htab
->elf
.dynamic_sections_created
)
3492 /* Add some entries to the .dynamic section. We fill in the
3493 values later, in elf_i386_finish_dynamic_sections, but we
3494 must add the entries now so that we get the correct size for
3495 the .dynamic section. The DT_DEBUG entry is filled in by the
3496 dynamic linker and used by the debugger. */
3497 #define add_dynamic_entry(TAG, VAL) \
3498 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3500 if (bfd_link_executable (info
))
3502 if (!add_dynamic_entry (DT_DEBUG
, 0))
3506 if (htab
->elf
.splt
->size
!= 0)
3508 /* DT_PLTGOT is used by prelink even if there is no PLT
3510 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3514 if (htab
->elf
.srelplt
->size
!= 0)
3516 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3517 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3518 || !add_dynamic_entry (DT_JMPREL
, 0))
3524 if (!add_dynamic_entry (DT_REL
, 0)
3525 || !add_dynamic_entry (DT_RELSZ
, 0)
3526 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3529 /* If any dynamic relocs apply to a read-only section,
3530 then we need a DT_TEXTREL entry. */
3531 if ((info
->flags
& DF_TEXTREL
) == 0)
3532 elf_link_hash_traverse (&htab
->elf
,
3533 elf_i386_readonly_dynrelocs
, info
);
3535 if ((info
->flags
& DF_TEXTREL
) != 0)
3537 if (htab
->readonly_dynrelocs_against_ifunc
)
3539 info
->callbacks
->einfo
3540 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3541 bfd_set_error (bfd_error_bad_value
);
3545 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3549 if (get_elf_i386_backend_data (output_bfd
)->os
== is_vxworks
3550 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3553 #undef add_dynamic_entry
3559 elf_i386_always_size_sections (bfd
*output_bfd
,
3560 struct bfd_link_info
*info
)
3562 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3566 struct elf_link_hash_entry
*tlsbase
;
3568 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3569 "_TLS_MODULE_BASE_",
3570 FALSE
, FALSE
, FALSE
);
3572 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3574 struct elf_i386_link_hash_table
*htab
;
3575 struct bfd_link_hash_entry
*bh
= NULL
;
3576 const struct elf_backend_data
*bed
3577 = get_elf_backend_data (output_bfd
);
3579 htab
= elf_i386_hash_table (info
);
3583 if (!(_bfd_generic_link_add_one_symbol
3584 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3585 tls_sec
, 0, NULL
, FALSE
,
3586 bed
->collect
, &bh
)))
3589 htab
->tls_module_base
= bh
;
3591 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3592 tlsbase
->def_regular
= 1;
3593 tlsbase
->other
= STV_HIDDEN
;
3594 tlsbase
->root
.linker_def
= 1;
3595 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3602 /* Set the correct type for an x86 ELF section. We do this by the
3603 section name, which is a hack, but ought to work. */
3606 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3607 Elf_Internal_Shdr
*hdr
,
3612 name
= bfd_get_section_name (abfd
, sec
);
3614 /* This is an ugly, but unfortunately necessary hack that is
3615 needed when producing EFI binaries on x86. It tells
3616 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3617 containing ELF relocation info. We need this hack in order to
3618 be able to generate ELF binaries that can be translated into
3619 EFI applications (which are essentially COFF objects). Those
3620 files contain a COFF ".reloc" section inside an ELFNN object,
3621 which would normally cause BFD to segfault because it would
3622 attempt to interpret this section as containing relocation
3623 entries for section "oc". With this hack enabled, ".reloc"
3624 will be treated as a normal data section, which will avoid the
3625 segfault. However, you won't be able to create an ELFNN binary
3626 with a section named "oc" that needs relocations, but that's
3627 the kind of ugly side-effects you get when detecting section
3628 types based on their names... In practice, this limitation is
3629 unlikely to bite. */
3630 if (strcmp (name
, ".reloc") == 0)
3631 hdr
->sh_type
= SHT_PROGBITS
;
3636 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3637 executables. Rather than setting it to the beginning of the TLS
3638 section, we have to set it to the end. This function may be called
3639 multiple times, it is idempotent. */
3642 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3644 struct elf_i386_link_hash_table
*htab
;
3645 struct bfd_link_hash_entry
*base
;
3647 if (!bfd_link_executable (info
))
3650 htab
= elf_i386_hash_table (info
);
3654 base
= htab
->tls_module_base
;
3658 base
->u
.def
.value
= htab
->elf
.tls_size
;
3661 /* Return the base VMA address which should be subtracted from real addresses
3662 when resolving @dtpoff relocation.
3663 This is PT_TLS segment p_vaddr. */
3666 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3668 /* If tls_sec is NULL, we should have signalled an error already. */
3669 if (elf_hash_table (info
)->tls_sec
== NULL
)
3671 return elf_hash_table (info
)->tls_sec
->vma
;
3674 /* Return the relocation value for @tpoff relocation
3675 if STT_TLS virtual address is ADDRESS. */
3678 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3680 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3681 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3682 bfd_vma static_tls_size
;
3684 /* If tls_sec is NULL, we should have signalled an error already. */
3685 if (htab
->tls_sec
== NULL
)
3688 /* Consider special static TLS alignment requirements. */
3689 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3690 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3693 /* Relocate an i386 ELF section. */
3696 elf_i386_relocate_section (bfd
*output_bfd
,
3697 struct bfd_link_info
*info
,
3699 asection
*input_section
,
3701 Elf_Internal_Rela
*relocs
,
3702 Elf_Internal_Sym
*local_syms
,
3703 asection
**local_sections
)
3705 struct elf_i386_link_hash_table
*htab
;
3706 Elf_Internal_Shdr
*symtab_hdr
;
3707 struct elf_link_hash_entry
**sym_hashes
;
3708 bfd_vma
*local_got_offsets
;
3709 bfd_vma
*local_tlsdesc_gotents
;
3710 Elf_Internal_Rela
*rel
;
3711 Elf_Internal_Rela
*wrel
;
3712 Elf_Internal_Rela
*relend
;
3713 bfd_boolean is_vxworks_tls
;
3714 unsigned plt_entry_size
;
3716 BFD_ASSERT (is_i386_elf (input_bfd
));
3718 /* Skip if check_relocs failed. */
3719 if (input_section
->check_relocs_failed
)
3722 htab
= elf_i386_hash_table (info
);
3725 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3726 sym_hashes
= elf_sym_hashes (input_bfd
);
3727 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3728 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3729 /* We have to handle relocations in vxworks .tls_vars sections
3730 specially, because the dynamic loader is 'weird'. */
3731 is_vxworks_tls
= ((get_elf_i386_backend_data (output_bfd
)->os
3733 && bfd_link_pic (info
)
3734 && !strcmp (input_section
->output_section
->name
,
3737 elf_i386_set_tls_module_base (info
);
3739 plt_entry_size
= htab
->plt
.plt_entry_size
;
3741 rel
= wrel
= relocs
;
3742 relend
= relocs
+ input_section
->reloc_count
;
3743 for (; rel
< relend
; wrel
++, rel
++)
3745 unsigned int r_type
;
3746 reloc_howto_type
*howto
;
3747 unsigned long r_symndx
;
3748 struct elf_link_hash_entry
*h
;
3749 struct elf_i386_link_hash_entry
*eh
;
3750 Elf_Internal_Sym
*sym
;
3752 bfd_vma off
, offplt
, plt_offset
;
3754 bfd_boolean unresolved_reloc
;
3755 bfd_reloc_status_type r
;
3759 asection
*resolved_plt
;
3760 bfd_boolean resolved_to_zero
;
3761 bfd_boolean relative_reloc
;
3763 r_type
= ELF32_R_TYPE (rel
->r_info
);
3764 if (r_type
== R_386_GNU_VTINHERIT
3765 || r_type
== R_386_GNU_VTENTRY
)
3772 if ((indx
= r_type
) >= R_386_standard
3773 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3774 >= R_386_ext
- R_386_standard
)
3775 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3776 >= R_386_ext2
- R_386_ext
))
3779 /* xgettext:c-format */
3780 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3781 input_bfd
, r_type
, input_section
);
3782 bfd_set_error (bfd_error_bad_value
);
3785 howto
= elf_howto_table
+ indx
;
3787 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3791 unresolved_reloc
= FALSE
;
3792 if (r_symndx
< symtab_hdr
->sh_info
)
3794 sym
= local_syms
+ r_symndx
;
3795 sec
= local_sections
[r_symndx
];
3796 relocation
= (sec
->output_section
->vma
3797 + sec
->output_offset
3799 st_size
= sym
->st_size
;
3801 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3802 && ((sec
->flags
& SEC_MERGE
) != 0
3803 || (bfd_link_relocatable (info
)
3804 && sec
->output_offset
!= 0)))
3807 bfd_byte
*where
= contents
+ rel
->r_offset
;
3809 switch (howto
->size
)
3812 addend
= bfd_get_8 (input_bfd
, where
);
3813 if (howto
->pc_relative
)
3815 addend
= (addend
^ 0x80) - 0x80;
3820 addend
= bfd_get_16 (input_bfd
, where
);
3821 if (howto
->pc_relative
)
3823 addend
= (addend
^ 0x8000) - 0x8000;
3828 addend
= bfd_get_32 (input_bfd
, where
);
3829 if (howto
->pc_relative
)
3831 addend
= (addend
^ 0x80000000) - 0x80000000;
3839 if (bfd_link_relocatable (info
))
3840 addend
+= sec
->output_offset
;
3843 asection
*msec
= sec
;
3844 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3846 addend
-= relocation
;
3847 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3850 switch (howto
->size
)
3853 /* FIXME: overflow checks. */
3854 if (howto
->pc_relative
)
3856 bfd_put_8 (input_bfd
, addend
, where
);
3859 if (howto
->pc_relative
)
3861 bfd_put_16 (input_bfd
, addend
, where
);
3864 if (howto
->pc_relative
)
3866 bfd_put_32 (input_bfd
, addend
, where
);
3870 else if (!bfd_link_relocatable (info
)
3871 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3873 /* Relocate against local STT_GNU_IFUNC symbol. */
3874 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3879 /* Set STT_GNU_IFUNC symbol value. */
3880 h
->root
.u
.def
.value
= sym
->st_value
;
3881 h
->root
.u
.def
.section
= sec
;
3886 bfd_boolean warned ATTRIBUTE_UNUSED
;
3887 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3889 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3890 r_symndx
, symtab_hdr
, sym_hashes
,
3892 unresolved_reloc
, warned
, ignored
);
3896 if (sec
!= NULL
&& discarded_section (sec
))
3898 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3899 contents
+ rel
->r_offset
);
3900 wrel
->r_offset
= rel
->r_offset
;
3904 /* For ld -r, remove relocations in debug sections against
3905 sections defined in discarded sections. Not done for
3906 eh_frame editing code expects to be present. */
3907 if (bfd_link_relocatable (info
)
3908 && (input_section
->flags
& SEC_DEBUGGING
))
3914 if (bfd_link_relocatable (info
))
3921 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3922 it here if it is defined in a non-shared object. */
3924 && h
->type
== STT_GNU_IFUNC
3927 asection
*plt
, *gotplt
, *base_got
;
3931 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3933 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3934 sections because such sections are not SEC_ALLOC and
3935 thus ld.so will not process them. */
3936 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3941 /* STT_GNU_IFUNC symbol must go through PLT. */
3942 if (htab
->elf
.splt
!= NULL
)
3944 plt
= htab
->elf
.splt
;
3945 gotplt
= htab
->elf
.sgotplt
;
3949 plt
= htab
->elf
.iplt
;
3950 gotplt
= htab
->elf
.igotplt
;
3960 base_got
= htab
->elf
.sgot
;
3961 off
= h
->got
.offset
;
3963 if (base_got
== NULL
)
3966 if (off
== (bfd_vma
) -1)
3968 /* We can't use h->got.offset here to save state, or
3969 even just remember the offset, as finish_dynamic_symbol
3970 would use that as offset into .got. */
3972 if (h
->plt
.offset
== (bfd_vma
) -1)
3975 if (htab
->elf
.splt
!= NULL
)
3977 plt_index
= (h
->plt
.offset
/ plt_entry_size
3978 - htab
->plt
.has_plt0
);
3979 off
= (plt_index
+ 3) * 4;
3980 base_got
= htab
->elf
.sgotplt
;
3984 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3985 off
= plt_index
* 4;
3986 base_got
= htab
->elf
.igotplt
;
3989 if (h
->dynindx
== -1
3993 /* This references the local defitionion. We must
3994 initialize this entry in the global offset table.
3995 Since the offset must always be a multiple of 8,
3996 we use the least significant bit to record
3997 whether we have initialized it already.
3999 When doing a dynamic link, we create a .rela.got
4000 relocation entry to initialize the value. This
4001 is done in the finish_dynamic_symbol routine. */
4006 bfd_put_32 (output_bfd
, relocation
,
4007 base_got
->contents
+ off
);
4015 relocation
= (base_got
->output_section
->vma
4016 + base_got
->output_offset
+ off
4017 - gotplt
->output_section
->vma
4018 - gotplt
->output_offset
);
4020 if (rel
->r_offset
> 1
4021 && (*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5
4022 && *(contents
+ rel
->r_offset
- 2) != 0x8d)
4024 if (bfd_link_pic (info
))
4025 goto disallow_got32
;
4027 /* Add the GOT base if there is no base register. */
4028 relocation
+= (gotplt
->output_section
->vma
4029 + gotplt
->output_offset
);
4031 else if (htab
->elf
.splt
== NULL
)
4033 /* Adjust for static executables. */
4034 relocation
+= gotplt
->output_offset
;
4040 if (h
->plt
.offset
== (bfd_vma
) -1)
4042 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4043 if (r_type
== R_386_32
4044 && (input_section
->flags
& SEC_CODE
) == 0)
4045 goto do_ifunc_pointer
;
4046 goto bad_ifunc_reloc
;
4049 relocation
= (plt
->output_section
->vma
4050 + plt
->output_offset
+ h
->plt
.offset
);
4056 if (h
->root
.root
.string
)
4057 name
= h
->root
.root
.string
;
4059 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4062 /* xgettext:c-format */
4063 (_("%B: relocation %s against STT_GNU_IFUNC "
4064 "symbol `%s' isn't supported"), input_bfd
,
4066 bfd_set_error (bfd_error_bad_value
);
4070 /* Generate dynamic relcoation only when there is a
4071 non-GOT reference in a shared object. */
4072 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4073 || h
->plt
.offset
== (bfd_vma
) -1)
4075 Elf_Internal_Rela outrel
;
4080 /* Need a dynamic relocation to get the real function
4082 offset
= _bfd_elf_section_offset (output_bfd
,
4086 if (offset
== (bfd_vma
) -1
4087 || offset
== (bfd_vma
) -2)
4090 outrel
.r_offset
= (input_section
->output_section
->vma
4091 + input_section
->output_offset
4094 if (h
->dynindx
== -1
4096 || bfd_link_executable (info
))
4098 /* This symbol is resolved locally. */
4099 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4100 bfd_put_32 (output_bfd
,
4101 (h
->root
.u
.def
.value
4102 + h
->root
.u
.def
.section
->output_section
->vma
4103 + h
->root
.u
.def
.section
->output_offset
),
4107 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4109 /* Dynamic relocations are stored in
4110 1. .rel.ifunc section in PIC object.
4111 2. .rel.got section in dynamic executable.
4112 3. .rel.iplt section in static executable. */
4113 if (bfd_link_pic (info
))
4114 sreloc
= htab
->elf
.irelifunc
;
4115 else if (htab
->elf
.splt
!= NULL
)
4116 sreloc
= htab
->elf
.srelgot
;
4118 sreloc
= htab
->elf
.irelplt
;
4119 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4121 /* If this reloc is against an external symbol, we
4122 do not want to fiddle with the addend. Otherwise,
4123 we need to include the symbol value so that it
4124 becomes an addend for the dynamic reloc. For an
4125 internal symbol, we have updated addend. */
4134 relocation
-= (gotplt
->output_section
->vma
4135 + gotplt
->output_offset
);
4140 eh
= (struct elf_i386_link_hash_entry
*) h
;
4141 resolved_to_zero
= (eh
!= NULL
4142 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4149 /* Avoid optimizing _DYNAMIC since ld.so may use its
4150 link-time address. */
4151 if (h
== htab
->elf
.hdynamic
)
4154 if (bfd_link_pic (info
))
4156 /* It is OK to convert mov to lea and convert indirect
4157 branch to direct branch. It is OK to convert adc,
4158 add, and, cmp, or, sbb, sub, test, xor only when PIC
4160 unsigned int opcode
, addend
;
4161 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4164 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4165 if (opcode
!= 0x8b && opcode
!= 0xff)
4169 /* Resolve "mov GOT[(%reg)], %reg",
4170 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4171 and "binop foo@GOT[(%reg)], %reg". */
4173 || (h
->plt
.offset
== (bfd_vma
) -1
4174 && h
->got
.offset
== (bfd_vma
) -1)
4175 || htab
->elf
.sgotplt
== NULL
)
4178 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4179 + htab
->elf
.sgotplt
->output_offset
);
4181 /* It is relative to .got.plt section. */
4182 if (h
->got
.offset
!= (bfd_vma
) -1)
4183 /* Use GOT entry. Mask off the least significant bit in
4184 GOT offset which may be set by R_386_GOT32 processing
4186 relocation
= (htab
->elf
.sgot
->output_section
->vma
4187 + htab
->elf
.sgot
->output_offset
4188 + (h
->got
.offset
& ~1) - offplt
);
4190 /* Use GOTPLT entry. */
4191 relocation
= (h
->plt
.offset
/ plt_entry_size
4192 - htab
->plt
.has_plt0
+ 3) * 4;
4194 if (!bfd_link_pic (info
))
4196 /* If not PIC, add the .got.plt section address for
4197 baseless addressing. */
4199 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4200 if ((modrm
& 0xc7) == 0x5)
4201 relocation
+= offplt
;
4204 unresolved_reloc
= FALSE
;
4209 /* Relocation is to the entry for this symbol in the global
4211 if (htab
->elf
.sgot
== NULL
)
4214 relative_reloc
= FALSE
;
4219 off
= h
->got
.offset
;
4220 dyn
= htab
->elf
.dynamic_sections_created
;
4221 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4222 bfd_link_pic (info
),
4224 || (bfd_link_pic (info
)
4225 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4226 || (ELF_ST_VISIBILITY (h
->other
)
4227 && h
->root
.type
== bfd_link_hash_undefweak
))
4229 /* This is actually a static link, or it is a
4230 -Bsymbolic link and the symbol is defined
4231 locally, or the symbol was forced to be local
4232 because of a version file. We must initialize
4233 this entry in the global offset table. Since the
4234 offset must always be a multiple of 4, we use the
4235 least significant bit to record whether we have
4236 initialized it already.
4238 When doing a dynamic link, we create a .rel.got
4239 relocation entry to initialize the value. This
4240 is done in the finish_dynamic_symbol routine. */
4245 bfd_put_32 (output_bfd
, relocation
,
4246 htab
->elf
.sgot
->contents
+ off
);
4249 if (h
->dynindx
== -1
4251 && h
->root
.type
!= bfd_link_hash_undefweak
4252 && bfd_link_pic (info
))
4254 /* PR ld/21402: If this symbol isn't dynamic
4255 in PIC, generate R_386_RELATIVE here. */
4256 eh
->no_finish_dynamic_symbol
= 1;
4257 relative_reloc
= TRUE
;
4262 unresolved_reloc
= FALSE
;
4266 if (local_got_offsets
== NULL
)
4269 off
= local_got_offsets
[r_symndx
];
4271 /* The offset must always be a multiple of 4. We use
4272 the least significant bit to record whether we have
4273 already generated the necessary reloc. */
4278 bfd_put_32 (output_bfd
, relocation
,
4279 htab
->elf
.sgot
->contents
+ off
);
4280 local_got_offsets
[r_symndx
] |= 1;
4282 if (bfd_link_pic (info
))
4283 relative_reloc
= TRUE
;
4290 Elf_Internal_Rela outrel
;
4292 s
= htab
->elf
.srelgot
;
4296 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4297 + htab
->elf
.sgot
->output_offset
4299 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4300 elf_append_rel (output_bfd
, s
, &outrel
);
4303 if (off
>= (bfd_vma
) -2)
4306 relocation
= (htab
->elf
.sgot
->output_section
->vma
4307 + htab
->elf
.sgot
->output_offset
+ off
);
4308 if (rel
->r_offset
> 1
4309 && (*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5
4310 && *(contents
+ rel
->r_offset
- 2) != 0x8d)
4312 if (bfd_link_pic (info
))
4314 /* For PIC, disallow R_386_GOT32 without a base
4315 register, except for "lea foo@GOT, %reg", since
4316 we don't know what the GOT base is. */
4320 if (h
== NULL
|| h
->root
.root
.string
== NULL
)
4321 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4324 name
= h
->root
.root
.string
;
4327 /* xgettext:c-format */
4328 (_("%B: direct GOT relocation %s against `%s'"
4329 " without base register can not be used"
4330 " when making a shared object"),
4331 input_bfd
, howto
->name
, name
);
4332 bfd_set_error (bfd_error_bad_value
);
4338 /* Subtract the .got.plt section address only with a base
4340 relocation
-= (htab
->elf
.sgotplt
->output_section
->vma
4341 + htab
->elf
.sgotplt
->output_offset
);
4347 /* Relocation is relative to the start of the global offset
4350 /* Check to make sure it isn't a protected function or data
4351 symbol for shared library since it may not be local when
4352 used as function address or with copy relocation. We also
4353 need to make sure that a symbol is referenced locally. */
4354 if (!bfd_link_executable (info
) && h
)
4356 if (!h
->def_regular
)
4360 switch (ELF_ST_VISIBILITY (h
->other
))
4363 v
= _("hidden symbol");
4366 v
= _("internal symbol");
4369 v
= _("protected symbol");
4377 /* xgettext:c-format */
4378 (_("%B: relocation R_386_GOTOFF against undefined %s"
4379 " `%s' can not be used when making a shared object"),
4380 input_bfd
, v
, h
->root
.root
.string
);
4381 bfd_set_error (bfd_error_bad_value
);
4384 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4385 && (h
->type
== STT_FUNC
4386 || h
->type
== STT_OBJECT
)
4387 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4390 /* xgettext:c-format */
4391 (_("%B: relocation R_386_GOTOFF against protected %s"
4392 " `%s' can not be used when making a shared object"),
4394 h
->type
== STT_FUNC
? "function" : "data",
4395 h
->root
.root
.string
);
4396 bfd_set_error (bfd_error_bad_value
);
4401 /* Note that sgot is not involved in this
4402 calculation. We always want the start of .got.plt. If we
4403 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4404 permitted by the ABI, we might have to change this
4406 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4407 + htab
->elf
.sgotplt
->output_offset
;
4411 /* Use global offset table as symbol value. */
4412 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4413 + htab
->elf
.sgotplt
->output_offset
;
4414 unresolved_reloc
= FALSE
;
4418 /* Relocation is to the entry for this symbol in the
4419 procedure linkage table. */
4421 /* Resolve a PLT32 reloc against a local symbol directly,
4422 without using the procedure linkage table. */
4426 if ((h
->plt
.offset
== (bfd_vma
) -1
4427 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4428 || htab
->elf
.splt
== NULL
)
4430 /* We didn't make a PLT entry for this symbol. This
4431 happens when statically linking PIC code, or when
4432 using -Bsymbolic. */
4436 if (h
->plt
.offset
!= (bfd_vma
) -1)
4438 resolved_plt
= htab
->elf
.splt
;
4439 plt_offset
= h
->plt
.offset
;
4443 resolved_plt
= htab
->plt_got
;
4444 plt_offset
= eh
->plt_got
.offset
;
4447 relocation
= (resolved_plt
->output_section
->vma
4448 + resolved_plt
->output_offset
4450 unresolved_reloc
= FALSE
;
4454 /* Set to symbol size. */
4455 relocation
= st_size
;
4460 if ((input_section
->flags
& SEC_ALLOC
) == 0
4464 /* Copy dynamic function pointer relocations. Don't generate
4465 dynamic relocations against resolved undefined weak symbols
4466 in PIE, except for R_386_PC32. */
4467 if ((bfd_link_pic (info
)
4469 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4470 && (!resolved_to_zero
4471 || r_type
== R_386_PC32
))
4472 || h
->root
.type
!= bfd_link_hash_undefweak
))
4473 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4474 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4475 || (ELIMINATE_COPY_RELOCS
4476 && !bfd_link_pic (info
)
4480 || eh
->func_pointer_refcount
> 0
4481 || (h
->root
.type
== bfd_link_hash_undefweak
4482 && !resolved_to_zero
))
4483 && ((h
->def_dynamic
&& !h
->def_regular
)
4484 /* Undefined weak symbol is bound locally when
4486 || h
->root
.type
== bfd_link_hash_undefweak
)))
4488 Elf_Internal_Rela outrel
;
4489 bfd_boolean skip
, relocate
;
4492 /* When generating a shared object, these relocations
4493 are copied into the output file to be resolved at run
4500 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4502 if (outrel
.r_offset
== (bfd_vma
) -1)
4504 else if (outrel
.r_offset
== (bfd_vma
) -2)
4505 skip
= TRUE
, relocate
= TRUE
;
4506 outrel
.r_offset
+= (input_section
->output_section
->vma
4507 + input_section
->output_offset
);
4510 memset (&outrel
, 0, sizeof outrel
);
4513 && (r_type
== R_386_PC32
4514 || !(bfd_link_executable (info
)
4515 || SYMBOLIC_BIND (info
, h
))
4516 || !h
->def_regular
))
4517 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4520 /* This symbol is local, or marked to become local. */
4522 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4525 sreloc
= elf_section_data (input_section
)->sreloc
;
4527 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4529 r
= bfd_reloc_notsupported
;
4530 goto check_relocation_error
;
4533 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4535 /* If this reloc is against an external symbol, we do
4536 not want to fiddle with the addend. Otherwise, we
4537 need to include the symbol value so that it becomes
4538 an addend for the dynamic reloc. */
4545 if (!bfd_link_executable (info
))
4547 Elf_Internal_Rela outrel
;
4550 outrel
.r_offset
= rel
->r_offset
4551 + input_section
->output_section
->vma
4552 + input_section
->output_offset
;
4553 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4554 sreloc
= elf_section_data (input_section
)->sreloc
;
4557 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4562 case R_386_TLS_GOTDESC
:
4563 case R_386_TLS_DESC_CALL
:
4564 case R_386_TLS_IE_32
:
4565 case R_386_TLS_GOTIE
:
4566 tls_type
= GOT_UNKNOWN
;
4567 if (h
== NULL
&& local_got_offsets
)
4568 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4570 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4571 if (tls_type
== GOT_TLS_IE
)
4572 tls_type
= GOT_TLS_IE_NEG
;
4574 if (! elf_i386_tls_transition (info
, input_bfd
,
4575 input_section
, contents
,
4576 symtab_hdr
, sym_hashes
,
4577 &r_type
, tls_type
, rel
,
4578 relend
, h
, r_symndx
, TRUE
))
4581 if (r_type
== R_386_TLS_LE_32
)
4583 BFD_ASSERT (! unresolved_reloc
);
4584 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4589 /* GD->LE transition. */
4590 type
= *(contents
+ rel
->r_offset
- 2);
4594 leal foo@tlsgd(,%ebx,1), %eax
4595 call ___tls_get_addr@PLT
4598 subl $foo@tpoff, %eax
4599 (6 byte form of subl). */
4600 roff
= rel
->r_offset
+ 5;
4605 leal foo@tlsgd(%ebx), %eax
4606 call ___tls_get_addr@PLT
4609 leal foo@tlsgd(%reg), %eax
4610 call *___tls_get_addr@GOT(%reg)
4611 which may be converted to
4612 addr32 call ___tls_get_addr
4614 movl %gs:0, %eax; subl $foo@tpoff, %eax
4615 (6 byte form of subl). */
4616 roff
= rel
->r_offset
+ 6;
4618 memcpy (contents
+ roff
- 8,
4619 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4620 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4622 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4627 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4629 /* GDesc -> LE transition.
4630 It's originally something like:
4631 leal x@tlsdesc(%ebx), %eax
4635 Registers other than %eax may be set up here. */
4640 roff
= rel
->r_offset
;
4641 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4643 /* Now modify the instruction as appropriate. */
4644 /* aoliva FIXME: remove the above and xor the byte
4646 bfd_put_8 (output_bfd
, val
^ 0x86,
4647 contents
+ roff
- 1);
4648 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4652 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4654 /* GDesc -> LE transition.
4662 roff
= rel
->r_offset
;
4663 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4664 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4667 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4671 /* IE->LE transition:
4672 Originally it can be one of:
4680 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4683 /* movl foo, %eax. */
4684 bfd_put_8 (output_bfd
, 0xb8,
4685 contents
+ rel
->r_offset
- 1);
4691 type
= bfd_get_8 (input_bfd
,
4692 contents
+ rel
->r_offset
- 2);
4697 bfd_put_8 (output_bfd
, 0xc7,
4698 contents
+ rel
->r_offset
- 2);
4699 bfd_put_8 (output_bfd
,
4700 0xc0 | ((val
>> 3) & 7),
4701 contents
+ rel
->r_offset
- 1);
4705 bfd_put_8 (output_bfd
, 0x81,
4706 contents
+ rel
->r_offset
- 2);
4707 bfd_put_8 (output_bfd
,
4708 0xc0 | ((val
>> 3) & 7),
4709 contents
+ rel
->r_offset
- 1);
4716 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4717 contents
+ rel
->r_offset
);
4722 unsigned int val
, type
;
4724 /* {IE_32,GOTIE}->LE transition:
4725 Originally it can be one of:
4726 subl foo(%reg1), %reg2
4727 movl foo(%reg1), %reg2
4728 addl foo(%reg1), %reg2
4731 movl $foo, %reg2 (6 byte form)
4732 addl $foo, %reg2. */
4733 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4734 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4738 bfd_put_8 (output_bfd
, 0xc7,
4739 contents
+ rel
->r_offset
- 2);
4740 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4741 contents
+ rel
->r_offset
- 1);
4743 else if (type
== 0x2b)
4746 bfd_put_8 (output_bfd
, 0x81,
4747 contents
+ rel
->r_offset
- 2);
4748 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4749 contents
+ rel
->r_offset
- 1);
4751 else if (type
== 0x03)
4754 bfd_put_8 (output_bfd
, 0x81,
4755 contents
+ rel
->r_offset
- 2);
4756 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4757 contents
+ rel
->r_offset
- 1);
4761 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4762 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4763 contents
+ rel
->r_offset
);
4765 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4766 contents
+ rel
->r_offset
);
4771 if (htab
->elf
.sgot
== NULL
)
4776 off
= h
->got
.offset
;
4777 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4781 if (local_got_offsets
== NULL
)
4784 off
= local_got_offsets
[r_symndx
];
4785 offplt
= local_tlsdesc_gotents
[r_symndx
];
4792 Elf_Internal_Rela outrel
;
4796 if (htab
->elf
.srelgot
== NULL
)
4799 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4801 if (GOT_TLS_GDESC_P (tls_type
))
4804 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4805 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4806 <= htab
->elf
.sgotplt
->size
);
4807 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4808 + htab
->elf
.sgotplt
->output_offset
4810 + htab
->sgotplt_jump_table_size
);
4811 sreloc
= htab
->elf
.srelplt
;
4812 loc
= sreloc
->contents
;
4813 loc
+= (htab
->next_tls_desc_index
++
4814 * sizeof (Elf32_External_Rel
));
4815 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4816 <= sreloc
->contents
+ sreloc
->size
);
4817 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4820 BFD_ASSERT (! unresolved_reloc
);
4821 bfd_put_32 (output_bfd
,
4822 relocation
- elf_i386_dtpoff_base (info
),
4823 htab
->elf
.sgotplt
->contents
+ offplt
4824 + htab
->sgotplt_jump_table_size
+ 4);
4828 bfd_put_32 (output_bfd
, 0,
4829 htab
->elf
.sgotplt
->contents
+ offplt
4830 + htab
->sgotplt_jump_table_size
+ 4);
4834 sreloc
= htab
->elf
.srelgot
;
4836 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4837 + htab
->elf
.sgot
->output_offset
+ off
);
4839 if (GOT_TLS_GD_P (tls_type
))
4840 dr_type
= R_386_TLS_DTPMOD32
;
4841 else if (GOT_TLS_GDESC_P (tls_type
))
4843 else if (tls_type
== GOT_TLS_IE_POS
)
4844 dr_type
= R_386_TLS_TPOFF
;
4846 dr_type
= R_386_TLS_TPOFF32
;
4848 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4849 bfd_put_32 (output_bfd
,
4850 relocation
- elf_i386_dtpoff_base (info
),
4851 htab
->elf
.sgot
->contents
+ off
);
4852 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4853 bfd_put_32 (output_bfd
,
4854 elf_i386_dtpoff_base (info
) - relocation
,
4855 htab
->elf
.sgot
->contents
+ off
);
4856 else if (dr_type
!= R_386_TLS_DESC
)
4857 bfd_put_32 (output_bfd
, 0,
4858 htab
->elf
.sgot
->contents
+ off
);
4859 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4861 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4863 if (GOT_TLS_GD_P (tls_type
))
4867 BFD_ASSERT (! unresolved_reloc
);
4868 bfd_put_32 (output_bfd
,
4869 relocation
- elf_i386_dtpoff_base (info
),
4870 htab
->elf
.sgot
->contents
+ off
+ 4);
4874 bfd_put_32 (output_bfd
, 0,
4875 htab
->elf
.sgot
->contents
+ off
+ 4);
4876 outrel
.r_info
= ELF32_R_INFO (indx
,
4877 R_386_TLS_DTPOFF32
);
4878 outrel
.r_offset
+= 4;
4879 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4882 else if (tls_type
== GOT_TLS_IE_BOTH
)
4884 bfd_put_32 (output_bfd
,
4886 ? relocation
- elf_i386_dtpoff_base (info
)
4888 htab
->elf
.sgot
->contents
+ off
+ 4);
4889 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4890 outrel
.r_offset
+= 4;
4891 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4898 local_got_offsets
[r_symndx
] |= 1;
4901 if (off
>= (bfd_vma
) -2
4902 && ! GOT_TLS_GDESC_P (tls_type
))
4904 if (r_type
== R_386_TLS_GOTDESC
4905 || r_type
== R_386_TLS_DESC_CALL
)
4907 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4908 unresolved_reloc
= FALSE
;
4910 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4912 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4913 + htab
->elf
.sgotplt
->output_offset
;
4914 relocation
= htab
->elf
.sgot
->output_section
->vma
4915 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4916 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4917 && tls_type
== GOT_TLS_IE_BOTH
)
4919 if (r_type
== R_386_TLS_IE
)
4920 relocation
+= g_o_t
;
4921 unresolved_reloc
= FALSE
;
4923 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4925 unsigned int val
, type
;
4928 /* GD->IE transition. */
4929 type
= *(contents
+ rel
->r_offset
- 2);
4930 val
= *(contents
+ rel
->r_offset
- 1);
4934 leal foo@tlsgd(,%ebx,1), %eax
4935 call ___tls_get_addr@PLT
4938 subl $foo@gottpoff(%ebx), %eax. */
4940 roff
= rel
->r_offset
- 3;
4945 leal foo@tlsgd(%ebx), %eax
4946 call ___tls_get_addr@PLT
4949 leal foo@tlsgd(%reg), %eax
4950 call *___tls_get_addr@GOT(%reg)
4951 which may be converted to
4952 addr32 call ___tls_get_addr
4955 subl $foo@gottpoff(%reg), %eax. */
4956 roff
= rel
->r_offset
- 2;
4958 memcpy (contents
+ roff
,
4959 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4960 contents
[roff
+ 7] = 0x80 | (val
& 7);
4961 /* If foo is used only with foo@gotntpoff(%reg) and
4962 foo@indntpoff, but not with foo@gottpoff(%reg), change
4963 subl $foo@gottpoff(%reg), %eax
4965 addl $foo@gotntpoff(%reg), %eax. */
4966 if (tls_type
== GOT_TLS_IE_POS
)
4967 contents
[roff
+ 6] = 0x03;
4968 bfd_put_32 (output_bfd
,
4969 htab
->elf
.sgot
->output_section
->vma
4970 + htab
->elf
.sgot
->output_offset
+ off
4971 - htab
->elf
.sgotplt
->output_section
->vma
4972 - htab
->elf
.sgotplt
->output_offset
,
4973 contents
+ roff
+ 8);
4974 /* Skip R_386_PLT32 and R_386_GOT32X. */
4979 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4981 /* GDesc -> IE transition.
4982 It's originally something like:
4983 leal x@tlsdesc(%ebx), %eax
4986 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4988 movl x@gottpoff(%ebx), %eax # before negl %eax
4990 Registers other than %eax may be set up here. */
4994 /* First, make sure it's a leal adding ebx to a 32-bit
4995 offset into any register, although it's probably
4996 almost always going to be eax. */
4997 roff
= rel
->r_offset
;
4999 /* Now modify the instruction as appropriate. */
5000 /* To turn a leal into a movl in the form we use it, it
5001 suffices to change the first byte from 0x8d to 0x8b.
5002 aoliva FIXME: should we decide to keep the leal, all
5003 we have to do is remove the statement below, and
5004 adjust the relaxation of R_386_TLS_DESC_CALL. */
5005 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5007 if (tls_type
== GOT_TLS_IE_BOTH
)
5010 bfd_put_32 (output_bfd
,
5011 htab
->elf
.sgot
->output_section
->vma
5012 + htab
->elf
.sgot
->output_offset
+ off
5013 - htab
->elf
.sgotplt
->output_section
->vma
5014 - htab
->elf
.sgotplt
->output_offset
,
5018 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
5020 /* GDesc -> IE transition.
5028 depending on how we transformed the TLS_GOTDESC above.
5033 roff
= rel
->r_offset
;
5035 /* Now modify the instruction as appropriate. */
5036 if (tls_type
!= GOT_TLS_IE_NEG
)
5039 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5040 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5045 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
5046 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
5056 if (! elf_i386_tls_transition (info
, input_bfd
,
5057 input_section
, contents
,
5058 symtab_hdr
, sym_hashes
,
5059 &r_type
, GOT_UNKNOWN
, rel
,
5060 relend
, h
, r_symndx
, TRUE
))
5063 if (r_type
!= R_386_TLS_LDM
)
5065 /* LD->LE transition. Change
5066 leal foo@tlsldm(%ebx) %eax
5067 call ___tls_get_addr@PLT
5071 leal 0(%esi,1), %esi
5073 leal foo@tlsldm(%reg) %eax
5074 call *___tls_get_addr@GOT(%reg)
5075 which may be converted to
5076 addr32 call ___tls_get_addr
5079 leal 0(%esi), %esi */
5080 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
5081 if (*(contents
+ rel
->r_offset
+ 4) == 0xff
5082 || *(contents
+ rel
->r_offset
+ 4) == 0x67)
5083 memcpy (contents
+ rel
->r_offset
- 2,
5084 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5086 memcpy (contents
+ rel
->r_offset
- 2,
5087 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5088 /* Skip R_386_PC32/R_386_PLT32. */
5094 if (htab
->elf
.sgot
== NULL
)
5097 off
= htab
->tls_ldm_got
.offset
;
5102 Elf_Internal_Rela outrel
;
5104 if (htab
->elf
.srelgot
== NULL
)
5107 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5108 + htab
->elf
.sgot
->output_offset
+ off
);
5110 bfd_put_32 (output_bfd
, 0,
5111 htab
->elf
.sgot
->contents
+ off
);
5112 bfd_put_32 (output_bfd
, 0,
5113 htab
->elf
.sgot
->contents
+ off
+ 4);
5114 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
5115 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
5116 htab
->tls_ldm_got
.offset
|= 1;
5118 relocation
= htab
->elf
.sgot
->output_section
->vma
5119 + htab
->elf
.sgot
->output_offset
+ off
5120 - htab
->elf
.sgotplt
->output_section
->vma
5121 - htab
->elf
.sgotplt
->output_offset
;
5122 unresolved_reloc
= FALSE
;
5125 case R_386_TLS_LDO_32
:
5126 if (!bfd_link_executable (info
)
5127 || (input_section
->flags
& SEC_CODE
) == 0)
5128 relocation
-= elf_i386_dtpoff_base (info
);
5130 /* When converting LDO to LE, we must negate. */
5131 relocation
= -elf_i386_tpoff (info
, relocation
);
5134 case R_386_TLS_LE_32
:
5136 if (!bfd_link_executable (info
))
5138 Elf_Internal_Rela outrel
;
5141 outrel
.r_offset
= rel
->r_offset
5142 + input_section
->output_section
->vma
5143 + input_section
->output_offset
;
5144 if (h
!= NULL
&& h
->dynindx
!= -1)
5148 if (r_type
== R_386_TLS_LE_32
)
5149 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
5151 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
5152 sreloc
= elf_section_data (input_section
)->sreloc
;
5155 elf_append_rel (output_bfd
, sreloc
, &outrel
);
5158 else if (r_type
== R_386_TLS_LE_32
)
5159 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
5161 relocation
-= elf_i386_dtpoff_base (info
);
5163 else if (r_type
== R_386_TLS_LE_32
)
5164 relocation
= elf_i386_tpoff (info
, relocation
);
5166 relocation
= -elf_i386_tpoff (info
, relocation
);
5173 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5174 because such sections are not SEC_ALLOC and thus ld.so will
5175 not process them. */
5176 if (unresolved_reloc
5177 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5179 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5180 rel
->r_offset
) != (bfd_vma
) -1)
5183 /* xgettext:c-format */
5184 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5187 (long) rel
->r_offset
,
5189 h
->root
.root
.string
);
5194 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5195 contents
, rel
->r_offset
,
5198 check_relocation_error
:
5199 if (r
!= bfd_reloc_ok
)
5204 name
= h
->root
.root
.string
;
5207 name
= bfd_elf_string_from_elf_section (input_bfd
,
5208 symtab_hdr
->sh_link
,
5213 name
= bfd_section_name (input_bfd
, sec
);
5216 if (r
== bfd_reloc_overflow
)
5217 (*info
->callbacks
->reloc_overflow
)
5218 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5219 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5223 /* xgettext:c-format */
5224 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5225 input_bfd
, input_section
,
5226 (long) rel
->r_offset
, name
, (int) r
);
5237 Elf_Internal_Shdr
*rel_hdr
;
5238 size_t deleted
= rel
- wrel
;
5240 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5241 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5242 if (rel_hdr
->sh_size
== 0)
5244 /* It is too late to remove an empty reloc section. Leave
5246 ??? What is wrong with an empty section??? */
5247 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5250 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5251 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5252 input_section
->reloc_count
-= deleted
;
5258 /* Finish up dynamic symbol handling. We set the contents of various
5259 dynamic sections here. */
5262 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5263 struct bfd_link_info
*info
,
5264 struct elf_link_hash_entry
*h
,
5265 Elf_Internal_Sym
*sym
)
5267 struct elf_i386_link_hash_table
*htab
;
5268 unsigned plt_entry_size
;
5269 const struct elf_i386_backend_data
*abed
;
5270 struct elf_i386_link_hash_entry
*eh
;
5271 bfd_boolean local_undefweak
;
5273 htab
= elf_i386_hash_table (info
);
5277 abed
= get_elf_i386_backend_data (output_bfd
);
5278 plt_entry_size
= htab
->plt
.plt_entry_size
;
5280 eh
= (struct elf_i386_link_hash_entry
*) h
;
5281 if (eh
->no_finish_dynamic_symbol
)
5284 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5285 resolved undefined weak symbols in executable so that their
5286 references have value 0 at run-time. */
5287 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5291 if (h
->plt
.offset
!= (bfd_vma
) -1)
5295 Elf_Internal_Rela rel
;
5297 asection
*plt
, *gotplt
, *relplt
;
5299 /* When building a static executable, use .iplt, .igot.plt and
5300 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5301 if (htab
->elf
.splt
!= NULL
)
5303 plt
= htab
->elf
.splt
;
5304 gotplt
= htab
->elf
.sgotplt
;
5305 relplt
= htab
->elf
.srelplt
;
5309 plt
= htab
->elf
.iplt
;
5310 gotplt
= htab
->elf
.igotplt
;
5311 relplt
= htab
->elf
.irelplt
;
5314 /* This symbol has an entry in the procedure linkage table. Set
5317 if ((h
->dynindx
== -1
5319 && !((h
->forced_local
|| bfd_link_executable (info
))
5321 && h
->type
== STT_GNU_IFUNC
))
5327 /* Get the index in the procedure linkage table which
5328 corresponds to this symbol. This is the index of this symbol
5329 in all the symbols for which we are making plt entries. The
5330 first entry in the procedure linkage table is reserved.
5332 Get the offset into the .got table of the entry that
5333 corresponds to this function. Each .got entry is 4 bytes.
5334 The first three are reserved.
5336 For static executables, we don't reserve anything. */
5338 if (plt
== htab
->elf
.splt
)
5340 got_offset
= (h
->plt
.offset
/ plt_entry_size
5341 - htab
->plt
.has_plt0
);
5342 got_offset
= (got_offset
+ 3) * 4;
5346 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5347 got_offset
= got_offset
* 4;
5350 /* Fill in the entry in the procedure linkage table and update
5352 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
5354 if (! bfd_link_pic (info
))
5356 bfd_put_32 (output_bfd
,
5357 (gotplt
->output_section
->vma
5358 + gotplt
->output_offset
5360 plt
->contents
+ h
->plt
.offset
5361 + htab
->plt
.plt_got_offset
);
5363 if (abed
->os
== is_vxworks
)
5365 int s
, k
, reloc_index
;
5367 /* Create the R_386_32 relocation referencing the GOT
5368 for this PLT entry. */
5370 /* S: Current slot number (zero-based). */
5371 s
= ((h
->plt
.offset
- htab
->plt
.plt_entry_size
)
5372 / htab
->plt
.plt_entry_size
);
5373 /* K: Number of relocations for PLTResolve. */
5374 if (bfd_link_pic (info
))
5375 k
= PLTRESOLVE_RELOCS_SHLIB
;
5377 k
= PLTRESOLVE_RELOCS
;
5378 /* Skip the PLTresolve relocations, and the relocations for
5379 the other PLT slots. */
5380 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5381 loc
= (htab
->srelplt2
->contents
+ reloc_index
5382 * sizeof (Elf32_External_Rel
));
5384 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5385 + htab
->elf
.splt
->output_offset
5386 + h
->plt
.offset
+ 2),
5387 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5388 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5390 /* Create the R_386_32 relocation referencing the beginning of
5391 the PLT for this GOT entry. */
5392 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5393 + htab
->elf
.sgotplt
->output_offset
5395 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5396 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5397 loc
+ sizeof (Elf32_External_Rel
));
5402 bfd_put_32 (output_bfd
, got_offset
,
5403 plt
->contents
+ h
->plt
.offset
5404 + htab
->plt
.plt_got_offset
);
5407 /* Fill in the entry in the global offset table. Leave the entry
5408 as zero for undefined weak symbol in PIE. No PLT relocation
5409 against undefined weak symbol in PIE. */
5410 if (!local_undefweak
)
5412 if (htab
->plt
.has_plt0
)
5413 bfd_put_32 (output_bfd
,
5414 (plt
->output_section
->vma
5415 + plt
->output_offset
5417 + htab
->lazy_plt
->plt_lazy_offset
),
5418 gotplt
->contents
+ got_offset
);
5420 /* Fill in the entry in the .rel.plt section. */
5421 rel
.r_offset
= (gotplt
->output_section
->vma
5422 + gotplt
->output_offset
5424 if (h
->dynindx
== -1
5425 || ((bfd_link_executable (info
)
5426 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5428 && h
->type
== STT_GNU_IFUNC
))
5430 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5431 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5432 in the .got.plt section. */
5433 bfd_put_32 (output_bfd
,
5434 (h
->root
.u
.def
.value
5435 + h
->root
.u
.def
.section
->output_section
->vma
5436 + h
->root
.u
.def
.section
->output_offset
),
5437 gotplt
->contents
+ got_offset
);
5438 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5439 /* R_386_IRELATIVE comes last. */
5440 plt_index
= htab
->next_irelative_index
--;
5444 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5445 plt_index
= htab
->next_jump_slot_index
++;
5448 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5449 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5451 /* Don't fill the second and third slots in PLT entry for
5452 static executables nor without PLT0. */
5453 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
5455 bfd_put_32 (output_bfd
,
5456 plt_index
* sizeof (Elf32_External_Rel
),
5457 plt
->contents
+ h
->plt
.offset
5458 + htab
->lazy_plt
->plt_reloc_offset
);
5459 bfd_put_32 (output_bfd
,
5461 + htab
->lazy_plt
->plt_plt_offset
+ 4),
5462 (plt
->contents
+ h
->plt
.offset
5463 + htab
->lazy_plt
->plt_plt_offset
));
5467 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5469 bfd_vma got_offset
, plt_offset
;
5470 asection
*plt
, *got
, *gotplt
;
5471 const bfd_byte
*got_plt_entry
;
5473 /* Set the entry in the GOT procedure linkage table. */
5474 plt
= htab
->plt_got
;
5475 got
= htab
->elf
.sgot
;
5476 gotplt
= htab
->elf
.sgotplt
;
5477 got_offset
= h
->got
.offset
;
5479 if (got_offset
== (bfd_vma
) -1
5485 /* Fill in the entry in the GOT procedure linkage table. */
5486 if (! bfd_link_pic (info
))
5488 got_plt_entry
= htab
->non_lazy_plt
->plt_entry
;
5489 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5493 got_plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
5494 got_offset
+= (got
->output_section
->vma
5495 + got
->output_offset
5496 - gotplt
->output_section
->vma
5497 - gotplt
->output_offset
);
5500 plt_offset
= eh
->plt_got
.offset
;
5501 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5502 htab
->non_lazy_plt
->plt_entry_size
);
5503 bfd_put_32 (output_bfd
, got_offset
,
5504 (plt
->contents
+ plt_offset
5505 + htab
->non_lazy_plt
->plt_got_offset
));
5508 if (!local_undefweak
5510 && (h
->plt
.offset
!= (bfd_vma
) -1
5511 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5513 /* Mark the symbol as undefined, rather than as defined in
5514 the .plt section. Leave the value if there were any
5515 relocations where pointer equality matters (this is a clue
5516 for the dynamic linker, to make function pointer
5517 comparisons work between an application and shared
5518 library), otherwise set it to zero. If a function is only
5519 called from a binary, there is no need to slow down
5520 shared libraries because of that. */
5521 sym
->st_shndx
= SHN_UNDEF
;
5522 if (!h
->pointer_equality_needed
)
5526 /* Don't generate dynamic GOT relocation against undefined weak
5527 symbol in executable. */
5528 if (h
->got
.offset
!= (bfd_vma
) -1
5529 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5530 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5531 && !local_undefweak
)
5533 Elf_Internal_Rela rel
;
5534 asection
*relgot
= htab
->elf
.srelgot
;
5536 /* This symbol has an entry in the global offset table. Set it
5539 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5542 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5543 + htab
->elf
.sgot
->output_offset
5544 + (h
->got
.offset
& ~(bfd_vma
) 1));
5546 /* If this is a static link, or it is a -Bsymbolic link and the
5547 symbol is defined locally or was forced to be local because
5548 of a version file, we just want to emit a RELATIVE reloc.
5549 The entry in the global offset table will already have been
5550 initialized in the relocate_section function. */
5552 && h
->type
== STT_GNU_IFUNC
)
5554 if (h
->plt
.offset
== (bfd_vma
) -1)
5556 /* STT_GNU_IFUNC is referenced without PLT. */
5557 if (htab
->elf
.splt
== NULL
)
5559 /* use .rel[a].iplt section to store .got relocations
5560 in static executable. */
5561 relgot
= htab
->elf
.irelplt
;
5563 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5565 bfd_put_32 (output_bfd
,
5566 (h
->root
.u
.def
.value
5567 + h
->root
.u
.def
.section
->output_section
->vma
5568 + h
->root
.u
.def
.section
->output_offset
),
5569 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5570 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5575 else if (bfd_link_pic (info
))
5577 /* Generate R_386_GLOB_DAT. */
5584 if (!h
->pointer_equality_needed
)
5587 /* For non-shared object, we can't use .got.plt, which
5588 contains the real function addres if we need pointer
5589 equality. We load the GOT entry with the PLT entry. */
5590 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5591 bfd_put_32 (output_bfd
,
5592 (plt
->output_section
->vma
5593 + plt
->output_offset
+ h
->plt
.offset
),
5594 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5598 else if (bfd_link_pic (info
)
5599 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5601 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5602 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5606 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5608 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5609 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5610 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5613 elf_append_rel (output_bfd
, relgot
, &rel
);
5618 Elf_Internal_Rela rel
;
5621 /* This symbol needs a copy reloc. Set it up. */
5623 if (h
->dynindx
== -1
5624 || (h
->root
.type
!= bfd_link_hash_defined
5625 && h
->root
.type
!= bfd_link_hash_defweak
)
5626 || htab
->elf
.srelbss
== NULL
5627 || htab
->elf
.sreldynrelro
== NULL
)
5630 rel
.r_offset
= (h
->root
.u
.def
.value
5631 + h
->root
.u
.def
.section
->output_section
->vma
5632 + h
->root
.u
.def
.section
->output_offset
);
5633 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5634 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
5635 s
= htab
->elf
.sreldynrelro
;
5637 s
= htab
->elf
.srelbss
;
5638 elf_append_rel (output_bfd
, s
, &rel
);
5644 /* Finish up local dynamic symbol handling. We set the contents of
5645 various dynamic sections here. */
5648 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5650 struct elf_link_hash_entry
*h
5651 = (struct elf_link_hash_entry
*) *slot
;
5652 struct bfd_link_info
*info
5653 = (struct bfd_link_info
*) inf
;
5655 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5659 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5660 here since undefined weak symbol may not be dynamic and may not be
5661 called for elf_i386_finish_dynamic_symbol. */
5664 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5667 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5668 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5670 if (h
->root
.type
!= bfd_link_hash_undefweak
5671 || h
->dynindx
!= -1)
5674 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5678 /* Used to decide how to sort relocs in an optimal manner for the
5679 dynamic linker, before writing them out. */
5681 static enum elf_reloc_type_class
5682 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5683 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5684 const Elf_Internal_Rela
*rela
)
5686 bfd
*abfd
= info
->output_bfd
;
5687 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5688 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5690 if (htab
->dynsym
!= NULL
5691 && htab
->dynsym
->contents
!= NULL
)
5693 /* Check relocation against STT_GNU_IFUNC symbol if there are
5695 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5696 if (r_symndx
!= STN_UNDEF
)
5698 Elf_Internal_Sym sym
;
5699 if (!bed
->s
->swap_symbol_in (abfd
,
5700 (htab
->dynsym
->contents
5701 + r_symndx
* sizeof (Elf32_External_Sym
)),
5705 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5706 return reloc_class_ifunc
;
5710 switch (ELF32_R_TYPE (rela
->r_info
))
5712 case R_386_IRELATIVE
:
5713 return reloc_class_ifunc
;
5714 case R_386_RELATIVE
:
5715 return reloc_class_relative
;
5716 case R_386_JUMP_SLOT
:
5717 return reloc_class_plt
;
5719 return reloc_class_copy
;
5721 return reloc_class_normal
;
5725 /* Finish up the dynamic sections. */
5728 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5729 struct bfd_link_info
*info
)
5731 struct elf_i386_link_hash_table
*htab
;
5734 const struct elf_i386_backend_data
*abed
;
5736 htab
= elf_i386_hash_table (info
);
5740 dynobj
= htab
->elf
.dynobj
;
5741 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5742 abed
= get_elf_i386_backend_data (output_bfd
);
5744 if (htab
->elf
.dynamic_sections_created
)
5746 Elf32_External_Dyn
*dyncon
, *dynconend
;
5748 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5751 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5752 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5753 for (; dyncon
< dynconend
; dyncon
++)
5755 Elf_Internal_Dyn dyn
;
5758 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5763 if (abed
->os
== is_vxworks
5764 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5769 s
= htab
->elf
.sgotplt
;
5770 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5774 s
= htab
->elf
.srelplt
;
5775 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5779 s
= htab
->elf
.srelplt
;
5780 dyn
.d_un
.d_val
= s
->size
;
5784 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5787 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5789 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5790 really seem like the right value. */
5791 elf_section_data (htab
->elf
.splt
->output_section
)
5792 ->this_hdr
.sh_entsize
= 4;
5794 if (htab
->plt
.has_plt0
)
5796 /* Fill in the special first entry in the procedure linkage
5798 memcpy (htab
->elf
.splt
->contents
, htab
->plt
.plt0_entry
,
5799 htab
->lazy_plt
->plt0_entry_size
);
5800 memset (htab
->elf
.splt
->contents
+ htab
->lazy_plt
->plt0_entry_size
,
5801 abed
->plt0_pad_byte
,
5802 htab
->plt
.plt_entry_size
- htab
->lazy_plt
->plt0_entry_size
);
5803 if (!bfd_link_pic (info
))
5805 bfd_put_32 (output_bfd
,
5806 (htab
->elf
.sgotplt
->output_section
->vma
5807 + htab
->elf
.sgotplt
->output_offset
5809 htab
->elf
.splt
->contents
5810 + htab
->lazy_plt
->plt0_got1_offset
);
5811 bfd_put_32 (output_bfd
,
5812 (htab
->elf
.sgotplt
->output_section
->vma
5813 + htab
->elf
.sgotplt
->output_offset
5815 htab
->elf
.splt
->contents
5816 + htab
->lazy_plt
->plt0_got2_offset
);
5818 if (abed
->os
== is_vxworks
)
5820 Elf_Internal_Rela rel
;
5821 int num_plts
= (htab
->elf
.splt
->size
5822 / htab
->plt
.plt_entry_size
) - 1;
5825 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5826 + 4. On IA32 we use REL relocations so the
5827 addend goes in the PLT directly. */
5828 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5829 + htab
->elf
.splt
->output_offset
5830 + htab
->lazy_plt
->plt0_got1_offset
);
5831 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5833 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5834 htab
->srelplt2
->contents
);
5835 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5837 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5838 + htab
->elf
.splt
->output_offset
5839 + htab
->lazy_plt
->plt0_got2_offset
);
5840 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5842 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5843 htab
->srelplt2
->contents
+
5844 sizeof (Elf32_External_Rel
));
5845 /* Correct the .rel.plt.unloaded relocations. */
5846 p
= htab
->srelplt2
->contents
;
5847 if (bfd_link_pic (info
))
5848 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5850 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5852 for (; num_plts
; num_plts
--)
5854 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5855 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5857 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5858 p
+= sizeof (Elf32_External_Rel
);
5860 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5861 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
,
5863 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5864 p
+= sizeof (Elf32_External_Rel
);
5871 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
5872 elf_section_data (htab
->plt_got
->output_section
)
5873 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
5876 /* Fill in the first three entries in the global offset table. */
5877 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
5879 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5882 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5886 bfd_put_32 (output_bfd
,
5888 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5889 htab
->elf
.sgotplt
->contents
);
5890 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5891 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5893 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5896 /* Adjust .eh_frame for .plt section. */
5897 if (htab
->plt_eh_frame
!= NULL
5898 && htab
->plt_eh_frame
->contents
!= NULL
)
5900 if (htab
->elf
.splt
!= NULL
5901 && htab
->elf
.splt
->size
!= 0
5902 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5903 && htab
->elf
.splt
->output_section
!= NULL
5904 && htab
->plt_eh_frame
->output_section
!= NULL
)
5906 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5907 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5908 + htab
->plt_eh_frame
->output_offset
5909 + PLT_FDE_START_OFFSET
;
5910 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5911 htab
->plt_eh_frame
->contents
5912 + PLT_FDE_START_OFFSET
);
5914 if (htab
->plt_eh_frame
->sec_info_type
5915 == SEC_INFO_TYPE_EH_FRAME
)
5917 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5919 htab
->plt_eh_frame
->contents
))
5924 /* Adjust .eh_frame for .plt.got section. */
5925 if (htab
->plt_got_eh_frame
!= NULL
5926 && htab
->plt_got_eh_frame
->contents
!= NULL
)
5928 if (htab
->plt_got
!= NULL
5929 && htab
->plt_got
->size
!= 0
5930 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
5931 && htab
->plt_got
->output_section
!= NULL
5932 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
5934 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
5935 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
5936 + htab
->plt_got_eh_frame
->output_offset
5937 + PLT_FDE_START_OFFSET
;
5938 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5939 htab
->plt_got_eh_frame
->contents
5940 + PLT_FDE_START_OFFSET
);
5942 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5944 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5945 htab
->plt_got_eh_frame
,
5946 htab
->plt_got_eh_frame
->contents
))
5951 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5952 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5954 /* Fill PLT entries for undefined weak symbols in PIE. */
5955 if (bfd_link_pie (info
))
5956 bfd_hash_traverse (&info
->hash
->table
,
5957 elf_i386_pie_finish_undefweak_symbol
,
5963 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5964 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5965 It has to be done before elf_link_sort_relocs is called so that
5966 dynamic relocations are properly sorted. */
5969 elf_i386_output_arch_local_syms
5970 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5971 struct bfd_link_info
*info
,
5972 void *flaginfo ATTRIBUTE_UNUSED
,
5973 int (*func
) (void *, const char *,
5976 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5978 struct elf_i386_link_hash_table
*htab
= elf_i386_hash_table (info
);
5982 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5983 htab_traverse (htab
->loc_hash_table
,
5984 elf_i386_finish_local_dynamic_symbol
,
5990 /* Sort relocs into address order. */
5993 compare_relocs (const void *ap
, const void *bp
)
5995 const arelent
*a
= * (const arelent
**) ap
;
5996 const arelent
*b
= * (const arelent
**) bp
;
5998 if (a
->address
> b
->address
)
6000 else if (a
->address
< b
->address
)
6006 enum elf_i386_plt_type
6019 enum elf_i386_plt_type type
;
6020 unsigned int plt_got_offset
;
6021 unsigned int plt_entry_size
;
6025 /* Forward declaration. */
6026 static const struct elf_i386_lazy_plt_layout elf_i386_nacl_plt
;
6028 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
6029 dynamic relocations. */
6032 elf_i386_get_synthetic_symtab (bfd
*abfd
,
6033 long symcount ATTRIBUTE_UNUSED
,
6034 asymbol
**syms ATTRIBUTE_UNUSED
,
6039 long size
, count
, i
, n
;
6041 unsigned int plt_got_offset
, plt_entry_size
;
6043 bfd_byte
*plt_contents
;
6044 long dynrelcount
, relsize
;
6045 arelent
**dynrelbuf
;
6046 const struct elf_i386_lazy_plt_layout
*lazy_plt
;
6047 const struct elf_i386_non_lazy_plt_layout
*non_lazy_plt
;
6051 enum elf_i386_plt_type plt_type
;
6052 struct elf_i386_plt plts
[] =
6054 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0 },
6055 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0 },
6061 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
6064 if (dynsymcount
<= 0)
6067 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
6071 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
6072 if (dynrelbuf
== NULL
)
6075 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
6078 /* Sort the relocs by address. */
6079 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*), compare_relocs
);
6081 non_lazy_plt
= NULL
;
6082 /* Silence GCC 6. */
6084 switch (get_elf_i386_backend_data (abfd
)->os
)
6087 non_lazy_plt
= &elf_i386_non_lazy_plt
;
6090 lazy_plt
= &elf_i386_lazy_plt
;
6093 lazy_plt
= &elf_i386_nacl_plt
;
6100 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6102 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
6106 /* Get the PLT section contents. */
6107 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6108 if (plt_contents
== NULL
)
6110 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6111 plt_contents
, 0, plt
->size
))
6113 free (plt_contents
);
6117 /* Check what kind of PLT it is. */
6118 plt_type
= plt_unknown
;
6119 if (plts
[j
].type
== plt_unknown
)
6121 /* Match lazy PLT first. */
6122 if (memcmp (plt_contents
, lazy_plt
->plt0_entry
,
6123 lazy_plt
->plt0_got1_offset
) == 0)
6124 plt_type
= plt_lazy
;
6125 else if (memcmp (plt_contents
, lazy_plt
->pic_plt0_entry
,
6126 lazy_plt
->plt0_got1_offset
) == 0)
6127 plt_type
= plt_lazy
| plt_pic
;
6130 if (non_lazy_plt
!= NULL
6131 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
))
6133 /* Match non-lazy PLT. */
6134 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
6135 non_lazy_plt
->plt_got_offset
) == 0)
6136 plt_type
= plt_non_lazy
;
6137 else if (memcmp (plt_contents
, non_lazy_plt
->pic_plt_entry
,
6138 non_lazy_plt
->plt_got_offset
) == 0)
6142 if (plt_type
== plt_unknown
)
6146 plts
[j
].type
= plt_type
;
6148 if ((plt_type
& plt_lazy
))
6150 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
6151 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
6152 /* Skip PLT0 in lazy PLT. */
6157 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
6158 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
6162 n
= plt
->size
/ plts
[j
].plt_entry_size
;
6166 plts
[j
].contents
= plt_contents
;
6168 /* The _GLOBAL_OFFSET_TABLE_ address is needed. */
6169 if ((plt_type
& plt_pic
))
6170 got_addr
= (bfd_vma
) -1;
6173 size
= count
* sizeof (asymbol
);
6174 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
6178 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6179 if (plts
[j
].contents
!= NULL
)
6180 free (plts
[j
].contents
);
6187 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
6189 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
6191 got_addr
= sec
->vma
;
6194 sec
= bfd_get_section_by_name (abfd
, ".got");
6196 got_addr
= sec
->vma
;
6199 if (got_addr
== (bfd_vma
) -1)
6203 /* Check for each PLT section. */
6206 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6207 if ((plt_contents
= plts
[j
].contents
) != NULL
)
6212 plt_got_offset
= plts
[j
].plt_got_offset
;
6213 plt_entry_size
= plts
[j
].plt_entry_size
;
6217 if ((plts
[j
].type
& plt_lazy
))
6219 /* Skip PLT0 in lazy PLT. */
6221 offset
= plt_entry_size
;
6229 /* Check each PLT entry against dynamic relocations. */
6230 for (; k
< plts
[j
].count
; k
++)
6237 /* Get the GOT offset, a signed 32-bit integer. */
6238 off
= H_GET_32 (abfd
, (plt_contents
+ offset
6240 got_vma
= got_addr
+ off
;
6242 /* Binary search. */
6246 while ((min
+ 1) < max
)
6250 mid
= (min
+ max
) / 2;
6252 if (got_vma
> r
->address
)
6254 else if (got_vma
< r
->address
)
6263 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6264 if (got_vma
== p
->address
6266 && (p
->howto
->type
== R_386_JUMP_SLOT
6267 || p
->howto
->type
== R_386_GLOB_DAT
6268 || p
->howto
->type
== R_386_IRELATIVE
))
6270 *s
= **p
->sym_ptr_ptr
;
6271 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6272 set. Since we are defining a symbol, ensure one
6274 if ((s
->flags
& BSF_LOCAL
) == 0)
6275 s
->flags
|= BSF_GLOBAL
;
6276 s
->flags
|= BSF_SYNTHETIC
;
6277 /* This is no longer a section symbol. */
6278 s
->flags
&= ~BSF_SECTION_SYM
;
6280 s
->the_bfd
= plt
->owner
;
6282 /* Store relocation for later use. */
6284 /* Add @plt to function name later. */
6285 size
+= strlen (s
->name
) + sizeof ("@plt");
6287 size
+= sizeof ("+0x") - 1 + 8;
6291 offset
+= plt_entry_size
;
6295 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
6301 /* Allocate space for @plt suffixes. */
6302 names
= (char *) bfd_malloc (size
);
6307 for (i
= 0; i
< count
; i
++)
6309 /* Add @plt to function name. */
6310 arelent
*p
= (arelent
*) s
->udata
.p
;
6313 size
= strlen (s
->name
);
6314 memcpy (names
, s
->name
, size
);
6321 memcpy (names
, "+0x", sizeof ("+0x") - 1);
6322 names
+= sizeof ("+0x") - 1;
6323 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
6324 for (a
= buf
; *a
== '0'; ++a
)
6327 memcpy (names
, a
, size
);
6330 memcpy (names
, "@plt", sizeof ("@plt"));
6331 names
+= sizeof ("@plt");
6335 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6336 if (plts
[j
].contents
!= NULL
)
6337 free (plts
[j
].contents
);
6344 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6347 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
6349 if (h
->plt
.offset
!= (bfd_vma
) -1
6351 && !h
->pointer_equality_needed
)
6354 return _bfd_elf_hash_symbol (h
);
6357 /* Parse i386 GNU properties. */
6359 static enum elf_property_kind
6360 elf_i386_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
6361 bfd_byte
*ptr
, unsigned int datasz
)
6367 case GNU_PROPERTY_X86_ISA_1_USED
:
6368 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
6372 ((type
== GNU_PROPERTY_X86_ISA_1_USED
6373 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
6374 : _("error: %B: <corrupt x86 ISA needed size: 0x%x>")),
6376 return property_corrupt
;
6378 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
6379 prop
->u
.number
= bfd_h_get_32 (abfd
, ptr
);
6380 prop
->pr_kind
= property_number
;
6384 return property_ignored
;
6387 return property_number
;
6390 /* Merge i386 GNU property BPROP with APROP. If APROP isn't NULL,
6391 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
6392 should be merged with ABFD. */
6395 elf_i386_merge_gnu_properties (bfd
*abfd ATTRIBUTE_UNUSED
,
6396 elf_property
*aprop
,
6397 elf_property
*bprop
)
6399 unsigned int number
;
6400 bfd_boolean updated
= FALSE
;
6401 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
6405 case GNU_PROPERTY_X86_ISA_1_USED
:
6406 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
6407 if (aprop
!= NULL
&& bprop
!= NULL
)
6409 number
= aprop
->u
.number
;
6410 aprop
->u
.number
= number
| bprop
->u
.number
;
6411 updated
= number
!= (unsigned int) aprop
->u
.number
;
6415 /* Return TRUE if APROP is NULL to indicate that BPROP should
6416 be added to ABFD. */
6417 updated
= aprop
== NULL
;
6422 /* Never should happen. */
6429 /* Set up i386 GNU properties. Return the first relocatable ELF input
6430 with GNU properties if found. Otherwise, return NULL. */
6433 elf_i386_link_setup_gnu_properties (struct bfd_link_info
*info
)
6435 bfd_boolean normal_target
;
6436 asection
*sec
, *pltsec
;
6438 unsigned int plt_alignment
;
6439 struct elf_i386_link_hash_table
*htab
;
6440 bfd
*pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
6442 if (bfd_link_relocatable (info
))
6445 htab
= elf_i386_hash_table (info
);
6449 dynobj
= htab
->elf
.dynobj
;
6451 /* Set htab->elf.dynobj here so that there is no need to check and
6452 set it in check_relocs. */
6457 /* Find a normal input file to hold linker created
6459 for (abfd
= info
->input_bfds
;
6461 abfd
= abfd
->link
.next
)
6463 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
6465 htab
->elf
.dynobj
= abfd
;
6471 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
6472 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
6473 canonical function address. */
6474 htab
->plt
.has_plt0
= 1;
6475 normal_target
= FALSE
;
6477 switch (get_elf_i386_backend_data (info
->output_bfd
)->os
)
6480 htab
->lazy_plt
= &elf_i386_lazy_plt
;
6481 htab
->non_lazy_plt
= &elf_i386_non_lazy_plt
;
6482 normal_target
= TRUE
;
6485 htab
->lazy_plt
= &elf_i386_lazy_plt
;
6486 htab
->non_lazy_plt
= NULL
;
6487 if (!elf_vxworks_create_dynamic_sections (dynobj
, info
,
6489 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
6492 htab
->lazy_plt
= &elf_i386_nacl_plt
;
6493 htab
->non_lazy_plt
= NULL
;
6497 pltsec
= htab
->elf
.splt
;
6499 /* If the non-lazy PLT is available, use it for all PLT entries if
6500 there are no PLT0 or no .plt section. */
6501 if (htab
->non_lazy_plt
!= NULL
6502 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
6504 if (bfd_link_pic (info
))
6506 = htab
->non_lazy_plt
->pic_plt_entry
;
6509 = htab
->non_lazy_plt
->plt_entry
;
6510 htab
->plt
.plt_entry_size
6511 = htab
->non_lazy_plt
->plt_entry_size
;
6512 htab
->plt
.plt_got_offset
6513 = htab
->non_lazy_plt
->plt_got_offset
;
6514 htab
->plt
.eh_frame_plt_size
6515 = htab
->non_lazy_plt
->eh_frame_plt_size
;
6516 htab
->plt
.eh_frame_plt
6517 = htab
->non_lazy_plt
->eh_frame_plt
;
6521 if (bfd_link_pic (info
))
6523 htab
->plt
.plt0_entry
6524 = htab
->lazy_plt
->pic_plt0_entry
;
6526 = htab
->lazy_plt
->pic_plt_entry
;
6530 htab
->plt
.plt0_entry
6531 = htab
->lazy_plt
->plt0_entry
;
6533 = htab
->lazy_plt
->plt_entry
;
6535 htab
->plt
.plt_entry_size
6536 = htab
->lazy_plt
->plt_entry_size
;
6537 htab
->plt
.plt_got_offset
6538 = htab
->lazy_plt
->plt_got_offset
;
6539 htab
->plt
.eh_frame_plt_size
6540 = htab
->lazy_plt
->eh_frame_plt_size
;
6541 htab
->plt
.eh_frame_plt
6542 = htab
->lazy_plt
->eh_frame_plt
;
6545 /* Return if there are no normal input files. */
6549 /* Since create_dynamic_sections isn't always called, but GOT
6550 relocations need GOT relocations, create them here so that we
6551 don't need to do it in check_relocs. */
6552 if (htab
->elf
.sgot
== NULL
6553 && !_bfd_elf_create_got_section (dynobj
, info
))
6554 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
6556 /* Create the ifunc sections here so that check_relocs can be
6558 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
6559 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
6561 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
6565 /* Whe creating executable, set the contents of the .interp
6566 section to the interpreter. */
6567 if (bfd_link_executable (info
) && !info
->nointerp
)
6569 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
6572 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
6573 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
6577 /* Don't change PLT section alignment for NaCl since it uses
6578 64-byte PLT entry and sets PLT section alignment to 32
6582 const struct elf_backend_data
*bed
6583 = get_elf_backend_data (dynobj
);
6584 flagword pltflags
= (bed
->dynamic_sec_flags
6589 unsigned int non_lazy_plt_alignment
6590 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
6593 if (!bfd_set_section_alignment (sec
->owner
, sec
,
6595 goto error_alignment
;
6597 /* Create the GOT procedure linkage table. */
6598 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6602 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
6604 if (!bfd_set_section_alignment (dynobj
, sec
,
6605 non_lazy_plt_alignment
))
6606 goto error_alignment
;
6608 htab
->plt_got
= sec
;
6611 if (!info
->no_ld_generated_unwind_info
)
6613 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
6614 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6615 | SEC_LINKER_CREATED
);
6617 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6621 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
6623 if (!bfd_set_section_alignment (dynobj
, sec
, 2))
6624 goto error_alignment
;
6626 htab
->plt_eh_frame
= sec
;
6628 if (htab
->plt_got
!= NULL
)
6630 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6634 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
6636 if (!bfd_set_section_alignment (dynobj
, sec
, 2))
6637 goto error_alignment
;
6639 htab
->plt_got_eh_frame
= sec
;
6646 /* The .iplt section is used for IFUNC symbols in static
6648 sec
= htab
->elf
.iplt
;
6650 && !bfd_set_section_alignment (sec
->owner
, sec
,
6654 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
6662 #define TARGET_LITTLE_SYM i386_elf32_vec
6663 #define TARGET_LITTLE_NAME "elf32-i386"
6664 #define ELF_ARCH bfd_arch_i386
6665 #define ELF_TARGET_ID I386_ELF_DATA
6666 #define ELF_MACHINE_CODE EM_386
6667 #define ELF_MAXPAGESIZE 0x1000
6669 #define elf_backend_can_gc_sections 1
6670 #define elf_backend_can_refcount 1
6671 #define elf_backend_want_got_plt 1
6672 #define elf_backend_plt_readonly 1
6673 #define elf_backend_want_plt_sym 0
6674 #define elf_backend_got_header_size 12
6675 #define elf_backend_plt_alignment 4
6676 #define elf_backend_dtrel_excludes_plt 1
6677 #define elf_backend_extern_protected_data 1
6678 #define elf_backend_caches_rawsize 1
6679 #define elf_backend_want_dynrelro 1
6681 /* Support RELA for objdump of prelink objects. */
6682 #define elf_info_to_howto elf_i386_info_to_howto_rel
6683 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6685 #define bfd_elf32_mkobject elf_i386_mkobject
6687 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6688 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6689 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6690 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6691 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6693 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6694 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6695 #define elf_backend_check_relocs elf_i386_check_relocs
6696 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6697 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
6698 #define elf_backend_fake_sections elf_i386_fake_sections
6699 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6700 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6701 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6702 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6703 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6704 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6705 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6706 #define elf_backend_relocate_section elf_i386_relocate_section
6707 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6708 #define elf_backend_always_size_sections elf_i386_always_size_sections
6709 #define elf_backend_omit_section_dynsym \
6710 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6711 #define elf_backend_hash_symbol elf_i386_hash_symbol
6712 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6713 #define elf_backend_parse_gnu_properties elf_i386_parse_gnu_properties
6714 #define elf_backend_merge_gnu_properties elf_i386_merge_gnu_properties
6715 #define elf_backend_setup_gnu_properties elf_i386_link_setup_gnu_properties
6717 #include "elf32-target.h"
6719 /* FreeBSD support. */
6721 #undef TARGET_LITTLE_SYM
6722 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6723 #undef TARGET_LITTLE_NAME
6724 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6726 #define ELF_OSABI ELFOSABI_FREEBSD
6728 /* The kernel recognizes executables as valid only if they carry a
6729 "FreeBSD" label in the ELF header. So we put this label on all
6730 executables and (for simplicity) also all other object files. */
6733 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
6735 _bfd_elf_post_process_headers (abfd
, info
);
6737 #ifdef OLD_FREEBSD_ABI_LABEL
6739 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6740 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6741 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
6746 #undef elf_backend_post_process_headers
6747 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6749 #define elf32_bed elf32_i386_fbsd_bed
6751 #undef elf_backend_add_symbol_hook
6753 #include "elf32-target.h"
6757 #undef TARGET_LITTLE_SYM
6758 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6759 #undef TARGET_LITTLE_NAME
6760 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6762 #undef elf_backend_post_process_headers
6764 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6765 objects won't be recognized. */
6769 #define elf32_bed elf32_i386_sol2_bed
6771 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6773 #undef elf_backend_static_tls_alignment
6774 #define elf_backend_static_tls_alignment 8
6776 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6778 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6780 #undef elf_backend_want_plt_sym
6781 #define elf_backend_want_plt_sym 1
6783 #undef elf_backend_strtab_flags
6784 #define elf_backend_strtab_flags SHF_STRINGS
6786 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6787 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6788 FALSE otherwise. ISECTION is the best guess matching section from the
6789 input bfd IBFD, but it might be NULL. */
6792 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6793 bfd
*obfd ATTRIBUTE_UNUSED
,
6794 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6795 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6797 /* PR 19938: FIXME: Need to add code for setting the sh_info
6798 and sh_link fields of Solaris specific section types. */
6801 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6802 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6804 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6806 The following values should be set:
6809 -----------------------------------------------------------------------------
6810 SHT_SUNW_ancillary The section header index of 0
6811 [0x6fffffee] the associated string table.
6813 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6814 [0x6ffffff0] the associated symbol table. section header index of
6816 SHT_SUNW_capchain table,
6819 SHT_SUNW_symsort The section header index of 0
6820 [0x6ffffff1] the associated symbol table.
6822 SHT_SUNW_tlssort The section header index of 0
6823 [0x6ffffff2] the associated symbol table.
6825 SHT_SUNW_LDYNSYM The section header index of One greater than the
6826 [0x6ffffff3] the associated string table. symbol table index of the
6827 This index is the same string last local symbol,
6828 table used by the SHT_DYNSYM STB_LOCAL. Since
6829 section. SHT_SUNW_LDYNSYM only
6830 contains local symbols,
6831 sh_info is equivalent to
6832 the number of symbols in
6835 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6836 [0x6ffffff5] the section header index of to named strings, the
6837 the associated section header index of
6838 SHT_SUNW_capinfo table, the associated string
6839 otherwise 0. table, otherwise 0.
6841 SHT_SUNW_move The section header index of 0
6842 [0x6ffffffa] the associated symbol table.
6847 SHT_SUNW_syminfo The section header index of The section header index
6848 [0x6ffffffc] the associated symbol table. of the associated
6851 SHT_SUNW_verdef The section header index of The number of version
6852 [0x6ffffffd] the associated string table. definitions within the
6855 SHT_SUNW_verneed The section header index of The number of version
6856 [0x6ffffffe] the associated string table. dependencies within the
6859 SHT_SUNW_versym The section header index of 0
6860 [0x6fffffff] the associated symbol table. */
6863 #undef elf_backend_copy_special_section_fields
6864 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6866 #include "elf32-target.h"
6868 /* Intel MCU support. */
6871 elf32_iamcu_elf_object_p (bfd
*abfd
)
6873 /* Set the right machine number for an IAMCU elf32 file. */
6874 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6878 #undef TARGET_LITTLE_SYM
6879 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6880 #undef TARGET_LITTLE_NAME
6881 #define TARGET_LITTLE_NAME "elf32-iamcu"
6883 #define ELF_ARCH bfd_arch_iamcu
6885 #undef ELF_MACHINE_CODE
6886 #define ELF_MACHINE_CODE EM_IAMCU
6891 #define elf32_bed elf32_iamcu_bed
6893 #undef elf_backend_object_p
6894 #define elf_backend_object_p elf32_iamcu_elf_object_p
6896 #undef elf_backend_static_tls_alignment
6898 #undef elf_backend_want_plt_sym
6899 #define elf_backend_want_plt_sym 0
6901 #undef elf_backend_strtab_flags
6902 #undef elf_backend_copy_special_section_fields
6904 #include "elf32-target.h"
6906 /* Restore defaults. */
6908 #define ELF_ARCH bfd_arch_i386
6909 #undef ELF_MACHINE_CODE
6910 #define ELF_MACHINE_CODE EM_386
6912 /* Native Client support. */
6914 #undef TARGET_LITTLE_SYM
6915 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6916 #undef TARGET_LITTLE_NAME
6917 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6919 #define elf32_bed elf32_i386_nacl_bed
6921 #undef ELF_MAXPAGESIZE
6922 #define ELF_MAXPAGESIZE 0x10000
6924 /* Restore defaults. */
6926 #undef elf_backend_want_plt_sym
6927 #define elf_backend_want_plt_sym 0
6928 #undef elf_backend_post_process_headers
6929 #undef elf_backend_static_tls_alignment
6931 /* NaCl uses substantially different PLT entries for the same effects. */
6933 #undef elf_backend_plt_alignment
6934 #define elf_backend_plt_alignment 5
6935 #define NACL_PLT_ENTRY_SIZE 64
6936 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6938 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6940 0xff, 0x35, /* pushl contents of address */
6941 0, 0, 0, 0, /* replaced with address of .got + 4. */
6942 0x8b, 0x0d, /* movl contents of address, %ecx */
6943 0, 0, 0, 0, /* replaced with address of .got + 8. */
6944 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6945 0xff, 0xe1 /* jmp *%ecx */
6948 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6950 0x8b, 0x0d, /* movl contents of address, %ecx */
6951 0, 0, 0, 0, /* replaced with GOT slot address. */
6952 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6953 0xff, 0xe1, /* jmp *%ecx */
6955 /* Pad to the next 32-byte boundary with nop instructions. */
6957 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6958 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6960 /* Lazy GOT entries point here (32-byte aligned). */
6961 0x68, /* pushl immediate */
6962 0, 0, 0, 0, /* replaced with reloc offset. */
6963 0xe9, /* jmp relative */
6964 0, 0, 0, 0, /* replaced with offset to .plt. */
6966 /* Pad to the next 32-byte boundary with nop instructions. */
6967 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6968 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6972 static const bfd_byte
6973 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6975 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6976 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6977 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6978 0xff, 0xe1, /* jmp *%ecx */
6980 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6981 so pad to that size with nop instructions. */
6982 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6985 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6987 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6988 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6989 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6990 0xff, 0xe1, /* jmp *%ecx */
6992 /* Pad to the next 32-byte boundary with nop instructions. */
6994 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6995 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6997 /* Lazy GOT entries point here (32-byte aligned). */
6998 0x68, /* pushl immediate */
6999 0, 0, 0, 0, /* replaced with offset into relocation table. */
7000 0xe9, /* jmp relative */
7001 0, 0, 0, 0, /* replaced with offset to start of .plt. */
7003 /* Pad to the next 32-byte boundary with nop instructions. */
7004 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
7005 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
7009 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
7011 #if (PLT_CIE_LENGTH != 20 \
7012 || PLT_FDE_LENGTH != 36 \
7013 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
7014 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
7015 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
7017 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
7018 0, 0, 0, 0, /* CIE ID */
7019 1, /* CIE version */
7020 'z', 'R', 0, /* Augmentation string */
7021 1, /* Code alignment factor */
7022 0x7c, /* Data alignment factor: -4 */
7023 8, /* Return address column */
7024 1, /* Augmentation size */
7025 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
7026 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
7027 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
7028 DW_CFA_nop
, DW_CFA_nop
,
7030 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
7031 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
7032 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
7033 0, 0, 0, 0, /* .plt size goes here */
7034 0, /* Augmentation size */
7035 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
7036 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
7037 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
7038 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
7039 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
7040 13, /* Block length */
7041 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
7042 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
7043 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
7044 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
7045 DW_CFA_nop
, DW_CFA_nop
7048 static const struct elf_i386_lazy_plt_layout elf_i386_nacl_plt
=
7050 elf_i386_nacl_plt0_entry
, /* plt0_entry */
7051 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
7052 2, /* plt0_got1_offset */
7053 8, /* plt0_got2_offset */
7054 elf_i386_nacl_plt_entry
, /* plt_entry */
7055 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
7056 2, /* plt_got_offset */
7057 33, /* plt_reloc_offset */
7058 38, /* plt_plt_offset */
7059 32, /* plt_lazy_offset */
7060 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
7061 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
7062 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
7063 sizeof (elf_i386_nacl_eh_frame_plt
) /* eh_frame_plt_size */
7066 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
7068 0x90, /* plt0_pad_byte: nop insn */
7073 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
7075 /* Set the right machine number for a NaCl i386 ELF32 file. */
7076 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
7080 #undef elf_backend_arch_data
7081 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
7083 #undef elf_backend_object_p
7084 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
7085 #undef elf_backend_modify_segment_map
7086 #define elf_backend_modify_segment_map nacl_modify_segment_map
7087 #undef elf_backend_modify_program_headers
7088 #define elf_backend_modify_program_headers nacl_modify_program_headers
7089 #undef elf_backend_final_write_processing
7090 #define elf_backend_final_write_processing nacl_final_write_processing
7092 #include "elf32-target.h"
7094 /* Restore defaults. */
7095 #undef elf_backend_object_p
7096 #undef elf_backend_modify_segment_map
7097 #undef elf_backend_modify_program_headers
7098 #undef elf_backend_final_write_processing
7100 /* VxWorks support. */
7102 #undef TARGET_LITTLE_SYM
7103 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
7104 #undef TARGET_LITTLE_NAME
7105 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
7107 #undef ELF_MAXPAGESIZE
7108 #define ELF_MAXPAGESIZE 0x1000
7109 #undef elf_backend_plt_alignment
7110 #define elf_backend_plt_alignment 4
7112 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
7114 0x90, /* plt0_pad_byte */
7118 #undef elf_backend_arch_data
7119 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
7121 #undef elf_backend_relocs_compatible
7122 #undef elf_backend_add_symbol_hook
7123 #define elf_backend_add_symbol_hook \
7124 elf_vxworks_add_symbol_hook
7125 #undef elf_backend_link_output_symbol_hook
7126 #define elf_backend_link_output_symbol_hook \
7127 elf_vxworks_link_output_symbol_hook
7128 #undef elf_backend_emit_relocs
7129 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7130 #undef elf_backend_final_write_processing
7131 #define elf_backend_final_write_processing \
7132 elf_vxworks_final_write_processing
7133 #undef elf_backend_static_tls_alignment
7135 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
7137 #undef elf_backend_want_plt_sym
7138 #define elf_backend_want_plt_sym 1
7141 #define elf32_bed elf32_i386_vxworks_bed
7143 #include "elf32-target.h"