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. start_stop is set on
1791 __start_SECNAME/__stop_SECNAME which mark section SECNAME. */
1794 || h
->root
.type
== bfd_link_hash_defined
1795 || h
->root
.type
== bfd_link_hash_defweak
)
1796 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)))
1803 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1804 "mov $foo, %reg2" with R_386_32. */
1806 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1807 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1812 /* Convert "mov foo@GOT(%reg1), %reg2" to
1813 "lea foo@GOTOFF(%reg1), %reg2". */
1814 r_type
= R_386_GOTOFF
;
1820 /* Only R_386_32 is supported. */
1826 /* Convert "test %reg1, foo@GOT(%reg2)" to
1827 "test $foo, %reg1". */
1828 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1833 /* Convert "binop foo@GOT(%reg1), %reg2" to
1834 "binop $foo, %reg2". */
1836 | (modrm
& 0x38) >> 3
1840 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1844 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1845 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1854 /* Rename some of the generic section flags to better document how they
1856 #define need_convert_load sec_flg0
1857 #define check_relocs_failed sec_flg1
1859 /* Look through the relocs for a section during the first phase, and
1860 calculate needed space in the global offset table, procedure linkage
1861 table, and dynamic reloc sections. */
1864 elf_i386_check_relocs (bfd
*abfd
,
1865 struct bfd_link_info
*info
,
1867 const Elf_Internal_Rela
*relocs
)
1869 struct elf_i386_link_hash_table
*htab
;
1870 Elf_Internal_Shdr
*symtab_hdr
;
1871 struct elf_link_hash_entry
**sym_hashes
;
1872 const Elf_Internal_Rela
*rel
;
1873 const Elf_Internal_Rela
*rel_end
;
1877 if (bfd_link_relocatable (info
))
1880 /* Don't do anything special with non-loaded, non-alloced sections.
1881 In particular, any relocs in such sections should not affect GOT
1882 and PLT reference counting (ie. we don't allow them to create GOT
1883 or PLT entries), there's no possibility or desire to optimize TLS
1884 relocs, and there's not much point in propagating relocs to shared
1885 libs that the dynamic linker won't relocate. */
1886 if ((sec
->flags
& SEC_ALLOC
) == 0)
1889 BFD_ASSERT (is_i386_elf (abfd
));
1891 htab
= elf_i386_hash_table (info
);
1894 sec
->check_relocs_failed
= 1;
1898 /* Get the section contents. */
1899 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1900 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1901 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1903 sec
->check_relocs_failed
= 1;
1907 symtab_hdr
= &elf_symtab_hdr (abfd
);
1908 sym_hashes
= elf_sym_hashes (abfd
);
1912 rel_end
= relocs
+ sec
->reloc_count
;
1913 for (rel
= relocs
; rel
< rel_end
; rel
++)
1915 unsigned int r_type
;
1916 unsigned long r_symndx
;
1917 struct elf_link_hash_entry
*h
;
1918 struct elf_i386_link_hash_entry
*eh
;
1919 Elf_Internal_Sym
*isym
;
1921 bfd_boolean size_reloc
;
1923 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1924 r_type
= ELF32_R_TYPE (rel
->r_info
);
1926 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1928 /* xgettext:c-format */
1929 _bfd_error_handler (_("%B: bad symbol index: %d"),
1934 if (r_symndx
< symtab_hdr
->sh_info
)
1936 /* A local symbol. */
1937 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1942 /* Check relocation against local STT_GNU_IFUNC symbol. */
1943 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1945 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1949 /* Fake a STT_GNU_IFUNC symbol. */
1950 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1952 h
->type
= STT_GNU_IFUNC
;
1955 h
->forced_local
= 1;
1956 h
->root
.type
= bfd_link_hash_defined
;
1964 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1965 while (h
->root
.type
== bfd_link_hash_indirect
1966 || h
->root
.type
== bfd_link_hash_warning
)
1967 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1970 eh
= (struct elf_i386_link_hash_entry
*) h
;
1973 if (r_type
== R_386_GOTOFF
)
1976 /* It is referenced by a non-shared object. */
1978 h
->root
.non_ir_ref_regular
= 1;
1980 if (h
->type
== STT_GNU_IFUNC
)
1981 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1982 |= elf_gnu_symbol_ifunc
;
1985 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1986 symtab_hdr
, sym_hashes
,
1987 &r_type
, GOT_UNKNOWN
,
1988 rel
, rel_end
, h
, r_symndx
, FALSE
))
1994 htab
->tls_ldm_got
.refcount
+= 1;
1998 /* This symbol requires a procedure linkage table entry. We
1999 actually build the entry in adjust_dynamic_symbol,
2000 because this might be a case of linking PIC code which is
2001 never referenced by a dynamic object, in which case we
2002 don't need to generate a procedure linkage table entry
2005 /* If this is a local symbol, we resolve it directly without
2006 creating a procedure linkage table entry. */
2010 eh
->has_got_reloc
= 1;
2012 h
->plt
.refcount
+= 1;
2019 case R_386_TLS_IE_32
:
2021 case R_386_TLS_GOTIE
:
2022 if (!bfd_link_executable (info
))
2023 info
->flags
|= DF_STATIC_TLS
;
2029 case R_386_TLS_GOTDESC
:
2030 case R_386_TLS_DESC_CALL
:
2031 /* This symbol requires a global offset table entry. */
2033 int tls_type
, old_tls_type
;
2040 tls_type
= GOT_NORMAL
;
2042 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
2043 case R_386_TLS_GOTDESC
:
2044 case R_386_TLS_DESC_CALL
:
2045 tls_type
= GOT_TLS_GDESC
; break;
2046 case R_386_TLS_IE_32
:
2047 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
2048 tls_type
= GOT_TLS_IE_NEG
;
2050 /* If this is a GD->IE transition, we may use either of
2051 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2052 tls_type
= GOT_TLS_IE
;
2055 case R_386_TLS_GOTIE
:
2056 tls_type
= GOT_TLS_IE_POS
; break;
2061 h
->got
.refcount
+= 1;
2062 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2066 bfd_signed_vma
*local_got_refcounts
;
2068 /* This is a global offset table entry for a local symbol. */
2069 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2070 if (local_got_refcounts
== NULL
)
2074 size
= symtab_hdr
->sh_info
;
2075 size
*= (sizeof (bfd_signed_vma
)
2076 + sizeof (bfd_vma
) + sizeof(char));
2077 local_got_refcounts
= (bfd_signed_vma
*)
2078 bfd_zalloc (abfd
, size
);
2079 if (local_got_refcounts
== NULL
)
2081 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2082 elf_i386_local_tlsdesc_gotent (abfd
)
2083 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2084 elf_i386_local_got_tls_type (abfd
)
2085 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2087 local_got_refcounts
[r_symndx
] += 1;
2088 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
2091 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
2092 tls_type
|= old_tls_type
;
2093 /* If a TLS symbol is accessed using IE at least once,
2094 there is no point to use dynamic model for it. */
2095 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2096 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2097 || (tls_type
& GOT_TLS_IE
) == 0))
2099 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
2100 tls_type
= old_tls_type
;
2101 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2102 && GOT_TLS_GD_ANY_P (tls_type
))
2103 tls_type
|= old_tls_type
;
2107 name
= h
->root
.root
.string
;
2109 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2112 /* xgettext:c-format */
2113 (_("%B: `%s' accessed both as normal and "
2114 "thread local symbol"),
2116 bfd_set_error (bfd_error_bad_value
);
2121 if (old_tls_type
!= tls_type
)
2124 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2126 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2134 if (r_type
!= R_386_TLS_IE
)
2137 eh
->has_got_reloc
= 1;
2142 case R_386_TLS_LE_32
:
2145 eh
->has_got_reloc
= 1;
2146 if (bfd_link_executable (info
))
2148 info
->flags
|= DF_STATIC_TLS
;
2153 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2154 eh
->has_non_got_reloc
= 1;
2156 /* We are called after all symbols have been resolved. Only
2157 relocation against STT_GNU_IFUNC symbol must go through
2160 && (bfd_link_executable (info
)
2161 || h
->type
== STT_GNU_IFUNC
))
2163 /* If this reloc is in a read-only section, we might
2164 need a copy reloc. We can't check reliably at this
2165 stage whether the section is read-only, as input
2166 sections have not yet been mapped to output sections.
2167 Tentatively set the flag for now, and correct in
2168 adjust_dynamic_symbol. */
2171 /* We may need a .plt entry if the symbol is a function
2172 defined in a shared lib or is a STT_GNU_IFUNC function
2173 referenced from the code or read-only section. */
2175 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2176 h
->plt
.refcount
+= 1;
2178 if (r_type
== R_386_PC32
)
2180 /* Since something like ".long foo - ." may be used
2181 as pointer, make sure that PLT is used if foo is
2182 a function defined in a shared library. */
2183 if ((sec
->flags
& SEC_CODE
) == 0)
2184 h
->pointer_equality_needed
= 1;
2185 else if (h
->type
== STT_GNU_IFUNC
2186 && bfd_link_pic (info
))
2189 /* xgettext:c-format */
2190 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2191 abfd
, h
->root
.root
.string
);
2192 bfd_set_error (bfd_error_bad_value
);
2198 h
->pointer_equality_needed
= 1;
2199 /* R_386_32 can be resolved at run-time. */
2200 if (r_type
== R_386_32
2201 && (sec
->flags
& SEC_READONLY
) == 0)
2202 eh
->func_pointer_refcount
+= 1;
2208 /* If we are creating a shared library, and this is a reloc
2209 against a global symbol, or a non PC relative reloc
2210 against a local symbol, then we need to copy the reloc
2211 into the shared library. However, if we are linking with
2212 -Bsymbolic, we do not need to copy a reloc against a
2213 global symbol which is defined in an object we are
2214 including in the link (i.e., DEF_REGULAR is set). At
2215 this point we have not seen all the input files, so it is
2216 possible that DEF_REGULAR is not set now but will be set
2217 later (it is never cleared). In case of a weak definition,
2218 DEF_REGULAR may be cleared later by a strong definition in
2219 a shared library. We account for that possibility below by
2220 storing information in the relocs_copied field of the hash
2221 table entry. A similar situation occurs when creating
2222 shared libraries and symbol visibility changes render the
2225 If on the other hand, we are creating an executable, we
2226 may need to keep relocations for symbols satisfied by a
2227 dynamic library if we manage to avoid copy relocs for the
2230 Generate dynamic pointer relocation against STT_GNU_IFUNC
2231 symbol in the non-code section. */
2232 if ((bfd_link_pic (info
)
2233 && (r_type
!= R_386_PC32
2235 && (! (bfd_link_pie (info
)
2236 || SYMBOLIC_BIND (info
, h
))
2237 || h
->root
.type
== bfd_link_hash_defweak
2238 || !h
->def_regular
))))
2240 && h
->type
== STT_GNU_IFUNC
2241 && r_type
== R_386_32
2242 && (sec
->flags
& SEC_CODE
) == 0)
2243 || (ELIMINATE_COPY_RELOCS
2244 && !bfd_link_pic (info
)
2246 && (h
->root
.type
== bfd_link_hash_defweak
2247 || !h
->def_regular
)))
2249 struct elf_dyn_relocs
*p
;
2250 struct elf_dyn_relocs
**head
;
2252 /* We must copy these reloc types into the output file.
2253 Create a reloc section in dynobj and make room for
2257 sreloc
= _bfd_elf_make_dynamic_reloc_section
2258 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2264 /* If this is a global symbol, we count the number of
2265 relocations we need for this symbol. */
2268 head
= &eh
->dyn_relocs
;
2272 /* Track dynamic relocs needed for local syms too.
2273 We really need local syms available to do this
2278 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2283 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2287 vpp
= &elf_section_data (s
)->local_dynrel
;
2288 head
= (struct elf_dyn_relocs
**)vpp
;
2292 if (p
== NULL
|| p
->sec
!= sec
)
2294 bfd_size_type amt
= sizeof *p
;
2295 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2307 /* Count size relocation as PC-relative relocation. */
2308 if (r_type
== R_386_PC32
|| size_reloc
)
2313 /* This relocation describes the C++ object vtable hierarchy.
2314 Reconstruct it for later use during GC. */
2315 case R_386_GNU_VTINHERIT
:
2316 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2320 /* This relocation describes which C++ vtable entries are actually
2321 used. Record for later use during GC. */
2322 case R_386_GNU_VTENTRY
:
2323 BFD_ASSERT (h
!= NULL
);
2325 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2333 if (r_type
== R_386_GOT32X
2334 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2335 sec
->need_convert_load
= 1;
2338 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2340 if (!info
->keep_memory
)
2344 /* Cache the section contents for elf_link_input_bfd. */
2345 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2352 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2354 sec
->check_relocs_failed
= 1;
2358 /* Return the section that should be marked against GC for a given
2362 elf_i386_gc_mark_hook (asection
*sec
,
2363 struct bfd_link_info
*info
,
2364 Elf_Internal_Rela
*rel
,
2365 struct elf_link_hash_entry
*h
,
2366 Elf_Internal_Sym
*sym
)
2369 switch (ELF32_R_TYPE (rel
->r_info
))
2371 case R_386_GNU_VTINHERIT
:
2372 case R_386_GNU_VTENTRY
:
2376 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2379 /* Remove undefined weak symbol from the dynamic symbol table if it
2380 is resolved to 0. */
2383 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2384 struct elf_link_hash_entry
*h
)
2386 if (h
->dynindx
!= -1
2387 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2388 elf_i386_hash_entry (h
)->has_got_reloc
,
2389 elf_i386_hash_entry (h
)))
2392 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2398 /* Adjust a symbol defined by a dynamic object and referenced by a
2399 regular object. The current definition is in some section of the
2400 dynamic object, but we're not including those sections. We have to
2401 change the definition to something the rest of the link can
2405 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2406 struct elf_link_hash_entry
*h
)
2408 struct elf_i386_link_hash_table
*htab
;
2410 struct elf_i386_link_hash_entry
*eh
;
2411 struct elf_dyn_relocs
*p
;
2413 /* STT_GNU_IFUNC symbol must go through PLT. */
2414 if (h
->type
== STT_GNU_IFUNC
)
2416 /* All local STT_GNU_IFUNC references must be treate as local
2417 calls via local PLT. */
2419 && SYMBOL_CALLS_LOCAL (info
, h
))
2421 bfd_size_type pc_count
= 0, count
= 0;
2422 struct elf_dyn_relocs
**pp
;
2424 eh
= (struct elf_i386_link_hash_entry
*) h
;
2425 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2427 pc_count
+= p
->pc_count
;
2428 p
->count
-= p
->pc_count
;
2437 if (pc_count
|| count
)
2442 /* Increment PLT reference count only for PC-relative
2445 if (h
->plt
.refcount
<= 0)
2446 h
->plt
.refcount
= 1;
2448 h
->plt
.refcount
+= 1;
2453 if (h
->plt
.refcount
<= 0)
2455 h
->plt
.offset
= (bfd_vma
) -1;
2461 /* If this is a function, put it in the procedure linkage table. We
2462 will fill in the contents of the procedure linkage table later,
2463 when we know the address of the .got section. */
2464 if (h
->type
== STT_FUNC
2467 if (h
->plt
.refcount
<= 0
2468 || SYMBOL_CALLS_LOCAL (info
, h
)
2469 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2470 && h
->root
.type
== bfd_link_hash_undefweak
))
2472 /* This case can occur if we saw a PLT32 reloc in an input
2473 file, but the symbol was never referred to by a dynamic
2474 object, or if all references were garbage collected. In
2475 such a case, we don't actually need to build a procedure
2476 linkage table, and we can just do a PC32 reloc instead. */
2477 h
->plt
.offset
= (bfd_vma
) -1;
2484 /* It's possible that we incorrectly decided a .plt reloc was
2485 needed for an R_386_PC32 reloc to a non-function sym in
2486 check_relocs. We can't decide accurately between function and
2487 non-function syms in check-relocs; Objects loaded later in
2488 the link may change h->type. So fix it now. */
2489 h
->plt
.offset
= (bfd_vma
) -1;
2491 /* If this is a weak symbol, and there is a real definition, the
2492 processor independent code will have arranged for us to see the
2493 real definition first, and we can just use the same value. */
2494 if (h
->u
.weakdef
!= NULL
)
2496 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2497 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2498 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2499 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2500 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2501 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2505 /* This is a reference to a symbol defined by a dynamic object which
2506 is not a function. */
2508 /* If we are creating a shared library, we must presume that the
2509 only references to the symbol are via the global offset table.
2510 For such cases we need not do anything here; the relocations will
2511 be handled correctly by relocate_section. */
2512 if (!bfd_link_executable (info
))
2515 /* If there are no references to this symbol that do not use the
2516 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2518 eh
= (struct elf_i386_link_hash_entry
*) h
;
2519 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2522 /* If -z nocopyreloc was given, we won't generate them either. */
2523 if (info
->nocopyreloc
)
2529 htab
= elf_i386_hash_table (info
);
2533 /* If there aren't any dynamic relocs in read-only sections nor
2534 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2535 avoid the copy reloc. This doesn't work on VxWorks, where we can
2536 not have dynamic relocations (other than copy and jump slot
2537 relocations) in an executable. */
2538 if (ELIMINATE_COPY_RELOCS
2540 && get_elf_i386_backend_data (info
->output_bfd
)->os
!= is_vxworks
)
2542 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2544 s
= p
->sec
->output_section
;
2545 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2556 /* We must allocate the symbol in our .dynbss section, which will
2557 become part of the .bss section of the executable. There will be
2558 an entry for this symbol in the .dynsym section. The dynamic
2559 object will contain position independent code, so all references
2560 from the dynamic object to this symbol will go through the global
2561 offset table. The dynamic linker will use the .dynsym entry to
2562 determine the address it must put in the global offset table, so
2563 both the dynamic object and the regular object will refer to the
2564 same memory location for the variable. */
2566 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2567 copy the initial value out of the dynamic object and into the
2568 runtime process image. */
2569 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2571 s
= htab
->elf
.sdynrelro
;
2572 srel
= htab
->elf
.sreldynrelro
;
2576 s
= htab
->elf
.sdynbss
;
2577 srel
= htab
->elf
.srelbss
;
2579 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2581 srel
->size
+= sizeof (Elf32_External_Rel
);
2585 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2588 /* Allocate space in .plt, .got and associated reloc sections for
2592 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2594 struct bfd_link_info
*info
;
2595 struct elf_i386_link_hash_table
*htab
;
2596 struct elf_i386_link_hash_entry
*eh
;
2597 struct elf_dyn_relocs
*p
;
2598 unsigned plt_entry_size
;
2599 bfd_boolean resolved_to_zero
;
2600 const struct elf_i386_backend_data
*bed
;
2602 if (h
->root
.type
== bfd_link_hash_indirect
)
2605 eh
= (struct elf_i386_link_hash_entry
*) h
;
2607 info
= (struct bfd_link_info
*) inf
;
2608 htab
= elf_i386_hash_table (info
);
2612 bed
= get_elf_i386_backend_data (info
->output_bfd
);
2614 plt_entry_size
= htab
->plt
.plt_entry_size
;
2616 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2620 /* Clear the reference count of function pointer relocations if
2621 symbol isn't a normal function. */
2622 if (h
->type
!= STT_FUNC
)
2623 eh
->func_pointer_refcount
= 0;
2625 /* We can't use the GOT PLT if pointer equality is needed since
2626 finish_dynamic_symbol won't clear symbol value and the dynamic
2627 linker won't update the GOT slot. We will get into an infinite
2628 loop at run-time. */
2629 if (htab
->plt_got
!= NULL
2630 && h
->type
!= STT_GNU_IFUNC
2631 && !h
->pointer_equality_needed
2632 && h
->plt
.refcount
> 0
2633 && h
->got
.refcount
> 0)
2635 /* Don't use the regular PLT if there are both GOT and GOTPLT
2637 h
->plt
.offset
= (bfd_vma
) -1;
2639 /* Use the GOT PLT. */
2640 eh
->plt_got
.refcount
= 1;
2643 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2644 here if it is defined and referenced in a non-shared object. */
2645 if (h
->type
== STT_GNU_IFUNC
2647 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2648 &htab
->readonly_dynrelocs_against_ifunc
,
2650 (htab
->plt
.has_plt0
*
2653 /* Don't create the PLT entry if there are only function pointer
2654 relocations which can be resolved at run-time. */
2655 else if (htab
->elf
.dynamic_sections_created
2656 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2657 || eh
->plt_got
.refcount
> 0))
2659 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
2661 /* Clear the reference count of function pointer relocations
2663 eh
->func_pointer_refcount
= 0;
2665 /* Make sure this symbol is output as a dynamic symbol.
2666 Undefined weak syms won't yet be marked as dynamic. */
2667 if (h
->dynindx
== -1
2669 && !resolved_to_zero
2670 && h
->root
.type
== bfd_link_hash_undefweak
)
2672 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2676 if (bfd_link_pic (info
)
2677 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2679 asection
*s
= htab
->elf
.splt
;
2680 asection
*got_s
= htab
->plt_got
;
2682 /* If this is the first .plt entry, make room for the special
2683 first entry. The .plt section is used by prelink to undo
2684 prelinking for dynamic relocations. */
2686 s
->size
= htab
->plt
.has_plt0
* plt_entry_size
;
2689 eh
->plt_got
.offset
= got_s
->size
;
2691 h
->plt
.offset
= s
->size
;
2693 /* If this symbol is not defined in a regular file, and we are
2694 not generating a shared library, then set the symbol to this
2695 location in the .plt. This is required to make function
2696 pointers compare as equal between the normal executable and
2697 the shared library. */
2698 if (! bfd_link_pic (info
)
2703 /* We need to make a call to the entry of the GOT PLT
2704 instead of regular PLT entry. */
2705 h
->root
.u
.def
.section
= got_s
;
2706 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2710 h
->root
.u
.def
.section
= s
;
2711 h
->root
.u
.def
.value
= h
->plt
.offset
;
2715 /* Make room for this entry. */
2717 got_s
->size
+= htab
->non_lazy_plt
->plt_entry_size
;
2720 s
->size
+= plt_entry_size
;
2722 /* We also need to make an entry in the .got.plt section,
2723 which will be placed in the .got section by the linker
2725 htab
->elf
.sgotplt
->size
+= 4;
2727 /* There should be no PLT relocation against resolved
2728 undefined weak symbol in executable. */
2729 if (!resolved_to_zero
)
2731 /* We also need to make an entry in the .rel.plt
2733 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2734 htab
->elf
.srelplt
->reloc_count
++;
2738 if (bed
->os
== is_vxworks
&& !bfd_link_pic (info
))
2740 /* VxWorks has a second set of relocations for each PLT entry
2741 in executables. They go in a separate relocation section,
2742 which is processed by the kernel loader. */
2744 /* There are two relocations for the initial PLT entry: an
2745 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2746 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2748 if (h
->plt
.offset
== plt_entry_size
)
2749 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2751 /* There are two extra relocations for each subsequent PLT entry:
2752 an R_386_32 relocation for the GOT entry, and an R_386_32
2753 relocation for the PLT entry. */
2755 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2760 eh
->plt_got
.offset
= (bfd_vma
) -1;
2761 h
->plt
.offset
= (bfd_vma
) -1;
2767 eh
->plt_got
.offset
= (bfd_vma
) -1;
2768 h
->plt
.offset
= (bfd_vma
) -1;
2772 eh
->tlsdesc_got
= (bfd_vma
) -1;
2774 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2775 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2776 if (h
->got
.refcount
> 0
2777 && bfd_link_executable (info
)
2779 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2780 h
->got
.offset
= (bfd_vma
) -1;
2781 else if (h
->got
.refcount
> 0)
2785 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2787 /* Make sure this symbol is output as a dynamic symbol.
2788 Undefined weak syms won't yet be marked as dynamic. */
2789 if (h
->dynindx
== -1
2791 && !resolved_to_zero
2792 && h
->root
.type
== bfd_link_hash_undefweak
)
2794 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2799 if (GOT_TLS_GDESC_P (tls_type
))
2801 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2802 - elf_i386_compute_jump_table_size (htab
);
2803 htab
->elf
.sgotplt
->size
+= 8;
2804 h
->got
.offset
= (bfd_vma
) -2;
2806 if (! GOT_TLS_GDESC_P (tls_type
)
2807 || GOT_TLS_GD_P (tls_type
))
2809 h
->got
.offset
= s
->size
;
2811 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2812 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2815 dyn
= htab
->elf
.dynamic_sections_created
;
2816 /* R_386_TLS_IE_32 needs one dynamic relocation,
2817 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2818 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2819 need two), R_386_TLS_GD needs one if local symbol and two if
2820 global. No dynamic relocation against resolved undefined weak
2821 symbol in executable. */
2822 if (tls_type
== GOT_TLS_IE_BOTH
)
2823 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2824 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2825 || (tls_type
& GOT_TLS_IE
))
2826 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2827 else if (GOT_TLS_GD_P (tls_type
))
2828 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2829 else if (! GOT_TLS_GDESC_P (tls_type
)
2830 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2831 && !resolved_to_zero
)
2832 || h
->root
.type
!= bfd_link_hash_undefweak
)
2833 && (bfd_link_pic (info
)
2834 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2835 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2836 if (GOT_TLS_GDESC_P (tls_type
))
2837 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2840 h
->got
.offset
= (bfd_vma
) -1;
2842 if (eh
->dyn_relocs
== NULL
)
2845 /* In the shared -Bsymbolic case, discard space allocated for
2846 dynamic pc-relative relocs against symbols which turn out to be
2847 defined in regular objects. For the normal shared case, discard
2848 space for pc-relative relocs that have become local due to symbol
2849 visibility changes. */
2851 if (bfd_link_pic (info
))
2853 /* The only reloc that uses pc_count is R_386_PC32, which will
2854 appear on a call or on something like ".long foo - .". We
2855 want calls to protected symbols to resolve directly to the
2856 function rather than going via the plt. If people want
2857 function pointer comparisons to work as expected then they
2858 should avoid writing assembly like ".long foo - .". */
2859 if (SYMBOL_CALLS_LOCAL (info
, h
))
2861 struct elf_dyn_relocs
**pp
;
2863 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2865 p
->count
-= p
->pc_count
;
2874 if (bed
->os
== is_vxworks
)
2876 struct elf_dyn_relocs
**pp
;
2877 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2879 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2886 /* Also discard relocs on undefined weak syms with non-default
2887 visibility or in PIE. */
2888 if (eh
->dyn_relocs
!= NULL
2889 && h
->root
.type
== bfd_link_hash_undefweak
)
2891 /* Undefined weak symbol is never bound locally in shared
2893 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2894 || resolved_to_zero
)
2898 /* Keep dynamic non-GOT/non-PLT relocation so that we
2899 can branch to 0 without PLT. */
2900 struct elf_dyn_relocs
**pp
;
2902 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2903 if (p
->pc_count
== 0)
2907 /* Remove non-R_386_PC32 relocation. */
2908 p
->count
= p
->pc_count
;
2912 if (eh
->dyn_relocs
!= NULL
)
2914 /* Make sure undefined weak symbols are output
2915 as dynamic symbols in PIEs for dynamic non-GOT
2916 non-PLT reloations. */
2917 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2922 eh
->dyn_relocs
= NULL
;
2924 else if (h
->dynindx
== -1
2925 && !h
->forced_local
)
2927 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2932 else if (ELIMINATE_COPY_RELOCS
)
2934 /* For the non-shared case, discard space for relocs against
2935 symbols which turn out to need copy relocs or are not
2936 dynamic. Keep dynamic relocations for run-time function
2937 pointer initialization. */
2939 if ((!h
->non_got_ref
2940 || eh
->func_pointer_refcount
> 0
2941 || (h
->root
.type
== bfd_link_hash_undefweak
2942 && !resolved_to_zero
))
2945 || (htab
->elf
.dynamic_sections_created
2946 && (h
->root
.type
== bfd_link_hash_undefweak
2947 || h
->root
.type
== bfd_link_hash_undefined
))))
2949 /* Make sure this symbol is output as a dynamic symbol.
2950 Undefined weak syms won't yet be marked as dynamic. */
2951 if (h
->dynindx
== -1
2953 && !resolved_to_zero
2954 && h
->root
.type
== bfd_link_hash_undefweak
)
2956 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2960 /* If that succeeded, we know we'll be keeping all the
2962 if (h
->dynindx
!= -1)
2966 eh
->dyn_relocs
= NULL
;
2967 eh
->func_pointer_refcount
= 0;
2972 /* Finally, allocate space. */
2973 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2977 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2979 BFD_ASSERT (sreloc
!= NULL
);
2980 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2986 /* Allocate space in .plt, .got and associated reloc sections for
2987 local dynamic relocs. */
2990 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2992 struct elf_link_hash_entry
*h
2993 = (struct elf_link_hash_entry
*) *slot
;
2995 if (h
->type
!= STT_GNU_IFUNC
2999 || h
->root
.type
!= bfd_link_hash_defined
)
3002 return elf_i386_allocate_dynrelocs (h
, inf
);
3005 /* Find any dynamic relocs that apply to read-only sections. */
3008 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3010 struct elf_i386_link_hash_entry
*eh
;
3011 struct elf_dyn_relocs
*p
;
3013 /* Skip local IFUNC symbols. */
3014 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3017 eh
= (struct elf_i386_link_hash_entry
*) h
;
3018 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3020 asection
*s
= p
->sec
->output_section
;
3022 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3024 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3026 info
->flags
|= DF_TEXTREL
;
3028 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3029 || info
->error_textrel
)
3030 /* xgettext:c-format */
3031 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3032 p
->sec
->owner
, h
->root
.root
.string
,
3035 /* Not an error, just cut short the traversal. */
3042 /* Convert load via the GOT slot to load immediate. */
3045 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
3046 struct bfd_link_info
*link_info
)
3048 struct elf_i386_link_hash_table
*htab
;
3049 Elf_Internal_Shdr
*symtab_hdr
;
3050 Elf_Internal_Rela
*internal_relocs
;
3051 Elf_Internal_Rela
*irel
, *irelend
;
3053 bfd_boolean changed
;
3054 bfd_signed_vma
*local_got_refcounts
;
3056 /* Don't even try to convert non-ELF outputs. */
3057 if (!is_elf_hash_table (link_info
->hash
))
3060 /* Nothing to do if there is no need or no output. */
3061 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3062 || sec
->need_convert_load
== 0
3063 || bfd_is_abs_section (sec
->output_section
))
3066 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3068 /* Load the relocations for this section. */
3069 internal_relocs
= (_bfd_elf_link_read_relocs
3070 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3071 link_info
->keep_memory
));
3072 if (internal_relocs
== NULL
)
3076 htab
= elf_i386_hash_table (link_info
);
3077 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3079 /* Get the section contents. */
3080 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3081 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3084 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3088 irelend
= internal_relocs
+ sec
->reloc_count
;
3089 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3091 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3092 unsigned int r_symndx
;
3093 struct elf_link_hash_entry
*h
;
3094 bfd_boolean converted
;
3096 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3097 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3098 if (r_type
!= R_386_GOT32X
)
3101 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3102 if (r_symndx
< symtab_hdr
->sh_info
)
3103 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3104 (const Elf_Internal_Rela
*) irel
,
3108 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3109 while (h
->root
.type
== bfd_link_hash_indirect
3110 || h
->root
.type
== bfd_link_hash_warning
)
3111 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3114 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3115 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3119 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3120 irel
, h
, &converted
, link_info
))
3125 changed
= converted
;
3128 if (h
->got
.refcount
> 0)
3129 h
->got
.refcount
-= 1;
3133 if (local_got_refcounts
!= NULL
3134 && local_got_refcounts
[r_symndx
] > 0)
3135 local_got_refcounts
[r_symndx
] -= 1;
3140 if (contents
!= NULL
3141 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3143 if (!changed
&& !link_info
->keep_memory
)
3147 /* Cache the section contents for elf_link_input_bfd. */
3148 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3152 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3155 free (internal_relocs
);
3157 elf_section_data (sec
)->relocs
= internal_relocs
;
3163 if (contents
!= NULL
3164 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3166 if (internal_relocs
!= NULL
3167 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3168 free (internal_relocs
);
3172 /* Set the sizes of the dynamic sections. */
3175 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3177 struct elf_i386_link_hash_table
*htab
;
3183 htab
= elf_i386_hash_table (info
);
3186 dynobj
= htab
->elf
.dynobj
;
3190 /* Set up .got offsets for local syms, and space for local dynamic
3192 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3194 bfd_signed_vma
*local_got
;
3195 bfd_signed_vma
*end_local_got
;
3196 char *local_tls_type
;
3197 bfd_vma
*local_tlsdesc_gotent
;
3198 bfd_size_type locsymcount
;
3199 Elf_Internal_Shdr
*symtab_hdr
;
3202 if (! is_i386_elf (ibfd
))
3205 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3207 struct elf_dyn_relocs
*p
;
3209 if (!elf_i386_convert_load (ibfd
, s
, info
))
3212 for (p
= ((struct elf_dyn_relocs
*)
3213 elf_section_data (s
)->local_dynrel
);
3217 if (!bfd_is_abs_section (p
->sec
)
3218 && bfd_is_abs_section (p
->sec
->output_section
))
3220 /* Input section has been discarded, either because
3221 it is a copy of a linkonce section or due to
3222 linker script /DISCARD/, so we'll be discarding
3225 else if ((get_elf_i386_backend_data (output_bfd
)->os
3227 && strcmp (p
->sec
->output_section
->name
,
3230 /* Relocations in vxworks .tls_vars sections are
3231 handled specially by the loader. */
3233 else if (p
->count
!= 0)
3235 srel
= elf_section_data (p
->sec
)->sreloc
;
3236 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3237 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3238 && (info
->flags
& DF_TEXTREL
) == 0)
3240 info
->flags
|= DF_TEXTREL
;
3241 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3242 || info
->error_textrel
)
3243 /* xgettext:c-format */
3244 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3245 p
->sec
->owner
, p
->sec
);
3251 local_got
= elf_local_got_refcounts (ibfd
);
3255 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3256 locsymcount
= symtab_hdr
->sh_info
;
3257 end_local_got
= local_got
+ locsymcount
;
3258 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3259 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3261 srel
= htab
->elf
.srelgot
;
3262 for (; local_got
< end_local_got
;
3263 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3265 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3268 if (GOT_TLS_GDESC_P (*local_tls_type
))
3270 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3271 - elf_i386_compute_jump_table_size (htab
);
3272 htab
->elf
.sgotplt
->size
+= 8;
3273 *local_got
= (bfd_vma
) -2;
3275 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3276 || GOT_TLS_GD_P (*local_tls_type
))
3278 *local_got
= s
->size
;
3280 if (GOT_TLS_GD_P (*local_tls_type
)
3281 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3284 if (bfd_link_pic (info
)
3285 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3286 || (*local_tls_type
& GOT_TLS_IE
))
3288 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3289 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3290 else if (GOT_TLS_GD_P (*local_tls_type
)
3291 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3292 srel
->size
+= sizeof (Elf32_External_Rel
);
3293 if (GOT_TLS_GDESC_P (*local_tls_type
))
3294 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3298 *local_got
= (bfd_vma
) -1;
3302 if (htab
->tls_ldm_got
.refcount
> 0)
3304 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3306 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3307 htab
->elf
.sgot
->size
+= 8;
3308 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3311 htab
->tls_ldm_got
.offset
= -1;
3313 /* Allocate global sym .plt and .got entries, and space for global
3314 sym dynamic relocs. */
3315 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3317 /* Allocate .plt and .got entries, and space for local symbols. */
3318 htab_traverse (htab
->loc_hash_table
,
3319 elf_i386_allocate_local_dynrelocs
,
3322 /* For every jump slot reserved in the sgotplt, reloc_count is
3323 incremented. However, when we reserve space for TLS descriptors,
3324 it's not incremented, so in order to compute the space reserved
3325 for them, it suffices to multiply the reloc count by the jump
3328 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3329 so that R_386_IRELATIVE entries come last. */
3330 if (htab
->elf
.srelplt
)
3332 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3333 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3334 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3336 else if (htab
->elf
.irelplt
)
3337 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3340 if (htab
->elf
.sgotplt
)
3342 /* Don't allocate .got.plt section if there are no GOT nor PLT
3343 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3344 if ((htab
->elf
.hgot
== NULL
3345 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3346 && (htab
->elf
.sgotplt
->size
3347 == get_elf_backend_data (output_bfd
)->got_header_size
)
3348 && (htab
->elf
.splt
== NULL
3349 || htab
->elf
.splt
->size
== 0)
3350 && (htab
->elf
.sgot
== NULL
3351 || htab
->elf
.sgot
->size
== 0)
3352 && (htab
->elf
.iplt
== NULL
3353 || htab
->elf
.iplt
->size
== 0)
3354 && (htab
->elf
.igotplt
== NULL
3355 || htab
->elf
.igotplt
->size
== 0))
3356 htab
->elf
.sgotplt
->size
= 0;
3359 if (_bfd_elf_eh_frame_present (info
))
3361 if (htab
->plt_eh_frame
!= NULL
3362 && htab
->elf
.splt
!= NULL
3363 && htab
->elf
.splt
->size
!= 0
3364 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
3365 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
3367 if (htab
->plt_got_eh_frame
!= NULL
3368 && htab
->plt_got
!= NULL
3369 && htab
->plt_got
->size
!= 0
3370 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
3371 htab
->plt_got_eh_frame
->size
3372 = htab
->non_lazy_plt
->eh_frame_plt_size
;
3375 /* We now have determined the sizes of the various dynamic sections.
3376 Allocate memory for them. */
3378 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3380 bfd_boolean strip_section
= TRUE
;
3382 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3385 if (s
== htab
->elf
.splt
3386 || s
== htab
->elf
.sgot
)
3388 /* Strip this section if we don't need it; see the
3390 /* We'd like to strip these sections if they aren't needed, but if
3391 we've exported dynamic symbols from them we must leave them.
3392 It's too late to tell BFD to get rid of the symbols. */
3394 if (htab
->elf
.hplt
!= NULL
)
3395 strip_section
= FALSE
;
3397 else if (s
== htab
->elf
.sgotplt
3398 || s
== htab
->elf
.iplt
3399 || s
== htab
->elf
.igotplt
3400 || s
== htab
->plt_got
3401 || s
== htab
->plt_eh_frame
3402 || s
== htab
->plt_got_eh_frame
3403 || s
== htab
->elf
.sdynbss
3404 || s
== htab
->elf
.sdynrelro
)
3406 /* Strip these too. */
3408 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3411 && s
!= htab
->elf
.srelplt
3412 && s
!= htab
->srelplt2
)
3415 /* We use the reloc_count field as a counter if we need
3416 to copy relocs into the output file. */
3421 /* It's not one of our sections, so don't allocate space. */
3427 /* If we don't need this section, strip it from the
3428 output file. This is mostly to handle .rel.bss and
3429 .rel.plt. We must create both sections in
3430 create_dynamic_sections, because they must be created
3431 before the linker maps input sections to output
3432 sections. The linker does that before
3433 adjust_dynamic_symbol is called, and it is that
3434 function which decides whether anything needs to go
3435 into these sections. */
3437 s
->flags
|= SEC_EXCLUDE
;
3441 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3444 /* Allocate memory for the section contents. We use bfd_zalloc
3445 here in case unused entries are not reclaimed before the
3446 section's contents are written out. This should not happen,
3447 but this way if it does, we get a R_386_NONE reloc instead
3449 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3450 if (s
->contents
== NULL
)
3454 if (htab
->plt_eh_frame
!= NULL
3455 && htab
->plt_eh_frame
->contents
!= NULL
)
3457 memcpy (htab
->plt_eh_frame
->contents
,
3458 htab
->plt
.eh_frame_plt
,
3459 htab
->plt_eh_frame
->size
);
3460 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3461 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3464 if (htab
->plt_got_eh_frame
!= NULL
3465 && htab
->plt_got_eh_frame
->contents
!= NULL
)
3467 memcpy (htab
->plt_got_eh_frame
->contents
,
3468 htab
->non_lazy_plt
->eh_frame_plt
,
3469 htab
->plt_got_eh_frame
->size
);
3470 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
3471 (htab
->plt_got_eh_frame
->contents
3472 + PLT_FDE_LEN_OFFSET
));
3475 if (htab
->elf
.dynamic_sections_created
)
3477 /* Add some entries to the .dynamic section. We fill in the
3478 values later, in elf_i386_finish_dynamic_sections, but we
3479 must add the entries now so that we get the correct size for
3480 the .dynamic section. The DT_DEBUG entry is filled in by the
3481 dynamic linker and used by the debugger. */
3482 #define add_dynamic_entry(TAG, VAL) \
3483 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3485 if (bfd_link_executable (info
))
3487 if (!add_dynamic_entry (DT_DEBUG
, 0))
3491 if (htab
->elf
.splt
->size
!= 0)
3493 /* DT_PLTGOT is used by prelink even if there is no PLT
3495 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3499 if (htab
->elf
.srelplt
->size
!= 0)
3501 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3502 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3503 || !add_dynamic_entry (DT_JMPREL
, 0))
3509 if (!add_dynamic_entry (DT_REL
, 0)
3510 || !add_dynamic_entry (DT_RELSZ
, 0)
3511 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3514 /* If any dynamic relocs apply to a read-only section,
3515 then we need a DT_TEXTREL entry. */
3516 if ((info
->flags
& DF_TEXTREL
) == 0)
3517 elf_link_hash_traverse (&htab
->elf
,
3518 elf_i386_readonly_dynrelocs
, info
);
3520 if ((info
->flags
& DF_TEXTREL
) != 0)
3522 if (htab
->readonly_dynrelocs_against_ifunc
)
3524 info
->callbacks
->einfo
3525 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3526 bfd_set_error (bfd_error_bad_value
);
3530 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3534 if (get_elf_i386_backend_data (output_bfd
)->os
== is_vxworks
3535 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3538 #undef add_dynamic_entry
3544 elf_i386_always_size_sections (bfd
*output_bfd
,
3545 struct bfd_link_info
*info
)
3547 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3551 struct elf_link_hash_entry
*tlsbase
;
3553 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3554 "_TLS_MODULE_BASE_",
3555 FALSE
, FALSE
, FALSE
);
3557 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3559 struct elf_i386_link_hash_table
*htab
;
3560 struct bfd_link_hash_entry
*bh
= NULL
;
3561 const struct elf_backend_data
*bed
3562 = get_elf_backend_data (output_bfd
);
3564 htab
= elf_i386_hash_table (info
);
3568 if (!(_bfd_generic_link_add_one_symbol
3569 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3570 tls_sec
, 0, NULL
, FALSE
,
3571 bed
->collect
, &bh
)))
3574 htab
->tls_module_base
= bh
;
3576 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3577 tlsbase
->def_regular
= 1;
3578 tlsbase
->other
= STV_HIDDEN
;
3579 tlsbase
->root
.linker_def
= 1;
3580 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3587 /* Set the correct type for an x86 ELF section. We do this by the
3588 section name, which is a hack, but ought to work. */
3591 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3592 Elf_Internal_Shdr
*hdr
,
3597 name
= bfd_get_section_name (abfd
, sec
);
3599 /* This is an ugly, but unfortunately necessary hack that is
3600 needed when producing EFI binaries on x86. It tells
3601 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3602 containing ELF relocation info. We need this hack in order to
3603 be able to generate ELF binaries that can be translated into
3604 EFI applications (which are essentially COFF objects). Those
3605 files contain a COFF ".reloc" section inside an ELFNN object,
3606 which would normally cause BFD to segfault because it would
3607 attempt to interpret this section as containing relocation
3608 entries for section "oc". With this hack enabled, ".reloc"
3609 will be treated as a normal data section, which will avoid the
3610 segfault. However, you won't be able to create an ELFNN binary
3611 with a section named "oc" that needs relocations, but that's
3612 the kind of ugly side-effects you get when detecting section
3613 types based on their names... In practice, this limitation is
3614 unlikely to bite. */
3615 if (strcmp (name
, ".reloc") == 0)
3616 hdr
->sh_type
= SHT_PROGBITS
;
3621 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3622 executables. Rather than setting it to the beginning of the TLS
3623 section, we have to set it to the end. This function may be called
3624 multiple times, it is idempotent. */
3627 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3629 struct elf_i386_link_hash_table
*htab
;
3630 struct bfd_link_hash_entry
*base
;
3632 if (!bfd_link_executable (info
))
3635 htab
= elf_i386_hash_table (info
);
3639 base
= htab
->tls_module_base
;
3643 base
->u
.def
.value
= htab
->elf
.tls_size
;
3646 /* Return the base VMA address which should be subtracted from real addresses
3647 when resolving @dtpoff relocation.
3648 This is PT_TLS segment p_vaddr. */
3651 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3653 /* If tls_sec is NULL, we should have signalled an error already. */
3654 if (elf_hash_table (info
)->tls_sec
== NULL
)
3656 return elf_hash_table (info
)->tls_sec
->vma
;
3659 /* Return the relocation value for @tpoff relocation
3660 if STT_TLS virtual address is ADDRESS. */
3663 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3665 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3666 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3667 bfd_vma static_tls_size
;
3669 /* If tls_sec is NULL, we should have signalled an error already. */
3670 if (htab
->tls_sec
== NULL
)
3673 /* Consider special static TLS alignment requirements. */
3674 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3675 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3678 /* Relocate an i386 ELF section. */
3681 elf_i386_relocate_section (bfd
*output_bfd
,
3682 struct bfd_link_info
*info
,
3684 asection
*input_section
,
3686 Elf_Internal_Rela
*relocs
,
3687 Elf_Internal_Sym
*local_syms
,
3688 asection
**local_sections
)
3690 struct elf_i386_link_hash_table
*htab
;
3691 Elf_Internal_Shdr
*symtab_hdr
;
3692 struct elf_link_hash_entry
**sym_hashes
;
3693 bfd_vma
*local_got_offsets
;
3694 bfd_vma
*local_tlsdesc_gotents
;
3695 Elf_Internal_Rela
*rel
;
3696 Elf_Internal_Rela
*wrel
;
3697 Elf_Internal_Rela
*relend
;
3698 bfd_boolean is_vxworks_tls
;
3699 unsigned plt_entry_size
;
3701 BFD_ASSERT (is_i386_elf (input_bfd
));
3703 /* Skip if check_relocs failed. */
3704 if (input_section
->check_relocs_failed
)
3707 htab
= elf_i386_hash_table (info
);
3710 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3711 sym_hashes
= elf_sym_hashes (input_bfd
);
3712 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3713 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3714 /* We have to handle relocations in vxworks .tls_vars sections
3715 specially, because the dynamic loader is 'weird'. */
3716 is_vxworks_tls
= ((get_elf_i386_backend_data (output_bfd
)->os
3718 && bfd_link_pic (info
)
3719 && !strcmp (input_section
->output_section
->name
,
3722 elf_i386_set_tls_module_base (info
);
3724 plt_entry_size
= htab
->plt
.plt_entry_size
;
3726 rel
= wrel
= relocs
;
3727 relend
= relocs
+ input_section
->reloc_count
;
3728 for (; rel
< relend
; wrel
++, rel
++)
3730 unsigned int r_type
;
3731 reloc_howto_type
*howto
;
3732 unsigned long r_symndx
;
3733 struct elf_link_hash_entry
*h
;
3734 struct elf_i386_link_hash_entry
*eh
;
3735 Elf_Internal_Sym
*sym
;
3737 bfd_vma off
, offplt
, plt_offset
;
3739 bfd_boolean unresolved_reloc
;
3740 bfd_reloc_status_type r
;
3744 asection
*resolved_plt
;
3745 bfd_boolean resolved_to_zero
;
3746 bfd_boolean relative_reloc
;
3748 r_type
= ELF32_R_TYPE (rel
->r_info
);
3749 if (r_type
== R_386_GNU_VTINHERIT
3750 || r_type
== R_386_GNU_VTENTRY
)
3757 if ((indx
= r_type
) >= R_386_standard
3758 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3759 >= R_386_ext
- R_386_standard
)
3760 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3761 >= R_386_ext2
- R_386_ext
))
3764 /* xgettext:c-format */
3765 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3766 input_bfd
, r_type
, input_section
);
3767 bfd_set_error (bfd_error_bad_value
);
3770 howto
= elf_howto_table
+ indx
;
3772 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3776 unresolved_reloc
= FALSE
;
3777 if (r_symndx
< symtab_hdr
->sh_info
)
3779 sym
= local_syms
+ r_symndx
;
3780 sec
= local_sections
[r_symndx
];
3781 relocation
= (sec
->output_section
->vma
3782 + sec
->output_offset
3784 st_size
= sym
->st_size
;
3786 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3787 && ((sec
->flags
& SEC_MERGE
) != 0
3788 || (bfd_link_relocatable (info
)
3789 && sec
->output_offset
!= 0)))
3792 bfd_byte
*where
= contents
+ rel
->r_offset
;
3794 switch (howto
->size
)
3797 addend
= bfd_get_8 (input_bfd
, where
);
3798 if (howto
->pc_relative
)
3800 addend
= (addend
^ 0x80) - 0x80;
3805 addend
= bfd_get_16 (input_bfd
, where
);
3806 if (howto
->pc_relative
)
3808 addend
= (addend
^ 0x8000) - 0x8000;
3813 addend
= bfd_get_32 (input_bfd
, where
);
3814 if (howto
->pc_relative
)
3816 addend
= (addend
^ 0x80000000) - 0x80000000;
3824 if (bfd_link_relocatable (info
))
3825 addend
+= sec
->output_offset
;
3828 asection
*msec
= sec
;
3829 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3831 addend
-= relocation
;
3832 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3835 switch (howto
->size
)
3838 /* FIXME: overflow checks. */
3839 if (howto
->pc_relative
)
3841 bfd_put_8 (input_bfd
, addend
, where
);
3844 if (howto
->pc_relative
)
3846 bfd_put_16 (input_bfd
, addend
, where
);
3849 if (howto
->pc_relative
)
3851 bfd_put_32 (input_bfd
, addend
, where
);
3855 else if (!bfd_link_relocatable (info
)
3856 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3858 /* Relocate against local STT_GNU_IFUNC symbol. */
3859 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3864 /* Set STT_GNU_IFUNC symbol value. */
3865 h
->root
.u
.def
.value
= sym
->st_value
;
3866 h
->root
.u
.def
.section
= sec
;
3871 bfd_boolean warned ATTRIBUTE_UNUSED
;
3872 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3874 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3875 r_symndx
, symtab_hdr
, sym_hashes
,
3877 unresolved_reloc
, warned
, ignored
);
3881 if (sec
!= NULL
&& discarded_section (sec
))
3883 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3884 contents
+ rel
->r_offset
);
3885 wrel
->r_offset
= rel
->r_offset
;
3889 /* For ld -r, remove relocations in debug sections against
3890 sections defined in discarded sections. Not done for
3891 eh_frame editing code expects to be present. */
3892 if (bfd_link_relocatable (info
)
3893 && (input_section
->flags
& SEC_DEBUGGING
))
3899 if (bfd_link_relocatable (info
))
3906 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3907 it here if it is defined in a non-shared object. */
3909 && h
->type
== STT_GNU_IFUNC
3912 asection
*plt
, *gotplt
, *base_got
;
3916 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3918 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3919 sections because such sections are not SEC_ALLOC and
3920 thus ld.so will not process them. */
3921 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3926 /* STT_GNU_IFUNC symbol must go through PLT. */
3927 if (htab
->elf
.splt
!= NULL
)
3929 plt
= htab
->elf
.splt
;
3930 gotplt
= htab
->elf
.sgotplt
;
3934 plt
= htab
->elf
.iplt
;
3935 gotplt
= htab
->elf
.igotplt
;
3945 base_got
= htab
->elf
.sgot
;
3946 off
= h
->got
.offset
;
3948 if (base_got
== NULL
)
3951 if (off
== (bfd_vma
) -1)
3953 /* We can't use h->got.offset here to save state, or
3954 even just remember the offset, as finish_dynamic_symbol
3955 would use that as offset into .got. */
3957 if (h
->plt
.offset
== (bfd_vma
) -1)
3960 if (htab
->elf
.splt
!= NULL
)
3962 plt_index
= (h
->plt
.offset
/ plt_entry_size
3963 - htab
->plt
.has_plt0
);
3964 off
= (plt_index
+ 3) * 4;
3965 base_got
= htab
->elf
.sgotplt
;
3969 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3970 off
= plt_index
* 4;
3971 base_got
= htab
->elf
.igotplt
;
3974 if (h
->dynindx
== -1
3978 /* This references the local defitionion. We must
3979 initialize this entry in the global offset table.
3980 Since the offset must always be a multiple of 8,
3981 we use the least significant bit to record
3982 whether we have initialized it already.
3984 When doing a dynamic link, we create a .rela.got
3985 relocation entry to initialize the value. This
3986 is done in the finish_dynamic_symbol routine. */
3991 bfd_put_32 (output_bfd
, relocation
,
3992 base_got
->contents
+ off
);
4000 relocation
= (base_got
->output_section
->vma
4001 + base_got
->output_offset
+ off
4002 - gotplt
->output_section
->vma
4003 - gotplt
->output_offset
);
4005 if (rel
->r_offset
> 1
4006 && (*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5
4007 && *(contents
+ rel
->r_offset
- 2) != 0x8d)
4009 if (bfd_link_pic (info
))
4010 goto disallow_got32
;
4012 /* Add the GOT base if there is no base register. */
4013 relocation
+= (gotplt
->output_section
->vma
4014 + gotplt
->output_offset
);
4016 else if (htab
->elf
.splt
== NULL
)
4018 /* Adjust for static executables. */
4019 relocation
+= gotplt
->output_offset
;
4025 if (h
->plt
.offset
== (bfd_vma
) -1)
4027 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4028 if (r_type
== R_386_32
4029 && (input_section
->flags
& SEC_CODE
) == 0)
4030 goto do_ifunc_pointer
;
4031 goto bad_ifunc_reloc
;
4034 relocation
= (plt
->output_section
->vma
4035 + plt
->output_offset
+ h
->plt
.offset
);
4041 if (h
->root
.root
.string
)
4042 name
= h
->root
.root
.string
;
4044 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4047 /* xgettext:c-format */
4048 (_("%B: relocation %s against STT_GNU_IFUNC "
4049 "symbol `%s' isn't supported"), input_bfd
,
4051 bfd_set_error (bfd_error_bad_value
);
4055 /* Generate dynamic relcoation only when there is a
4056 non-GOT reference in a shared object. */
4057 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4058 || h
->plt
.offset
== (bfd_vma
) -1)
4060 Elf_Internal_Rela outrel
;
4065 /* Need a dynamic relocation to get the real function
4067 offset
= _bfd_elf_section_offset (output_bfd
,
4071 if (offset
== (bfd_vma
) -1
4072 || offset
== (bfd_vma
) -2)
4075 outrel
.r_offset
= (input_section
->output_section
->vma
4076 + input_section
->output_offset
4079 if (h
->dynindx
== -1
4081 || bfd_link_executable (info
))
4083 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
4084 h
->root
.root
.string
,
4085 h
->root
.u
.def
.section
->owner
);
4087 /* This symbol is resolved locally. */
4088 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4089 bfd_put_32 (output_bfd
,
4090 (h
->root
.u
.def
.value
4091 + h
->root
.u
.def
.section
->output_section
->vma
4092 + h
->root
.u
.def
.section
->output_offset
),
4096 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4098 /* Dynamic relocations are stored in
4099 1. .rel.ifunc section in PIC object.
4100 2. .rel.got section in dynamic executable.
4101 3. .rel.iplt section in static executable. */
4102 if (bfd_link_pic (info
))
4103 sreloc
= htab
->elf
.irelifunc
;
4104 else if (htab
->elf
.splt
!= NULL
)
4105 sreloc
= htab
->elf
.srelgot
;
4107 sreloc
= htab
->elf
.irelplt
;
4108 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4110 /* If this reloc is against an external symbol, we
4111 do not want to fiddle with the addend. Otherwise,
4112 we need to include the symbol value so that it
4113 becomes an addend for the dynamic reloc. For an
4114 internal symbol, we have updated addend. */
4123 relocation
-= (gotplt
->output_section
->vma
4124 + gotplt
->output_offset
);
4129 eh
= (struct elf_i386_link_hash_entry
*) h
;
4130 resolved_to_zero
= (eh
!= NULL
4131 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4138 /* Avoid optimizing _DYNAMIC since ld.so may use its
4139 link-time address. */
4140 if (h
== htab
->elf
.hdynamic
)
4143 if (bfd_link_pic (info
))
4145 /* It is OK to convert mov to lea and convert indirect
4146 branch to direct branch. It is OK to convert adc,
4147 add, and, cmp, or, sbb, sub, test, xor only when PIC
4149 unsigned int opcode
, addend
;
4150 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4153 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4154 if (opcode
!= 0x8b && opcode
!= 0xff)
4158 /* Resolve "mov GOT[(%reg)], %reg",
4159 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4160 and "binop foo@GOT[(%reg)], %reg". */
4162 || (h
->plt
.offset
== (bfd_vma
) -1
4163 && h
->got
.offset
== (bfd_vma
) -1)
4164 || htab
->elf
.sgotplt
== NULL
)
4167 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4168 + htab
->elf
.sgotplt
->output_offset
);
4170 /* It is relative to .got.plt section. */
4171 if (h
->got
.offset
!= (bfd_vma
) -1)
4172 /* Use GOT entry. Mask off the least significant bit in
4173 GOT offset which may be set by R_386_GOT32 processing
4175 relocation
= (htab
->elf
.sgot
->output_section
->vma
4176 + htab
->elf
.sgot
->output_offset
4177 + (h
->got
.offset
& ~1) - offplt
);
4179 /* Use GOTPLT entry. */
4180 relocation
= (h
->plt
.offset
/ plt_entry_size
4181 - htab
->plt
.has_plt0
+ 3) * 4;
4183 if (!bfd_link_pic (info
))
4185 /* If not PIC, add the .got.plt section address for
4186 baseless addressing. */
4188 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4189 if ((modrm
& 0xc7) == 0x5)
4190 relocation
+= offplt
;
4193 unresolved_reloc
= FALSE
;
4198 /* Relocation is to the entry for this symbol in the global
4200 if (htab
->elf
.sgot
== NULL
)
4203 relative_reloc
= FALSE
;
4208 off
= h
->got
.offset
;
4209 dyn
= htab
->elf
.dynamic_sections_created
;
4210 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4211 bfd_link_pic (info
),
4213 || (bfd_link_pic (info
)
4214 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4215 || (ELF_ST_VISIBILITY (h
->other
)
4216 && h
->root
.type
== bfd_link_hash_undefweak
))
4218 /* This is actually a static link, or it is a
4219 -Bsymbolic link and the symbol is defined
4220 locally, or the symbol was forced to be local
4221 because of a version file. We must initialize
4222 this entry in the global offset table. Since the
4223 offset must always be a multiple of 4, we use the
4224 least significant bit to record whether we have
4225 initialized it already.
4227 When doing a dynamic link, we create a .rel.got
4228 relocation entry to initialize the value. This
4229 is done in the finish_dynamic_symbol routine. */
4234 bfd_put_32 (output_bfd
, relocation
,
4235 htab
->elf
.sgot
->contents
+ off
);
4238 if (h
->dynindx
== -1
4240 && h
->root
.type
!= bfd_link_hash_undefweak
4241 && bfd_link_pic (info
))
4243 /* PR ld/21402: If this symbol isn't dynamic
4244 in PIC, generate R_386_RELATIVE here. */
4245 eh
->no_finish_dynamic_symbol
= 1;
4246 relative_reloc
= TRUE
;
4251 unresolved_reloc
= FALSE
;
4255 if (local_got_offsets
== NULL
)
4258 off
= local_got_offsets
[r_symndx
];
4260 /* The offset must always be a multiple of 4. We use
4261 the least significant bit to record whether we have
4262 already generated the necessary reloc. */
4267 bfd_put_32 (output_bfd
, relocation
,
4268 htab
->elf
.sgot
->contents
+ off
);
4269 local_got_offsets
[r_symndx
] |= 1;
4271 if (bfd_link_pic (info
))
4272 relative_reloc
= TRUE
;
4279 Elf_Internal_Rela outrel
;
4281 s
= htab
->elf
.srelgot
;
4285 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4286 + htab
->elf
.sgot
->output_offset
4288 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4289 elf_append_rel (output_bfd
, s
, &outrel
);
4292 if (off
>= (bfd_vma
) -2)
4295 relocation
= (htab
->elf
.sgot
->output_section
->vma
4296 + htab
->elf
.sgot
->output_offset
+ off
);
4297 if (rel
->r_offset
> 1
4298 && (*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5
4299 && *(contents
+ rel
->r_offset
- 2) != 0x8d)
4301 if (bfd_link_pic (info
))
4303 /* For PIC, disallow R_386_GOT32 without a base
4304 register, except for "lea foo@GOT, %reg", since
4305 we don't know what the GOT base is. */
4309 if (h
== NULL
|| h
->root
.root
.string
== NULL
)
4310 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4313 name
= h
->root
.root
.string
;
4316 /* xgettext:c-format */
4317 (_("%B: direct GOT relocation %s against `%s'"
4318 " without base register can not be used"
4319 " when making a shared object"),
4320 input_bfd
, howto
->name
, name
);
4321 bfd_set_error (bfd_error_bad_value
);
4327 /* Subtract the .got.plt section address only with a base
4329 relocation
-= (htab
->elf
.sgotplt
->output_section
->vma
4330 + htab
->elf
.sgotplt
->output_offset
);
4336 /* Relocation is relative to the start of the global offset
4339 /* Check to make sure it isn't a protected function or data
4340 symbol for shared library since it may not be local when
4341 used as function address or with copy relocation. We also
4342 need to make sure that a symbol is referenced locally. */
4343 if (!bfd_link_executable (info
) && h
)
4345 if (!h
->def_regular
)
4349 switch (ELF_ST_VISIBILITY (h
->other
))
4352 v
= _("hidden symbol");
4355 v
= _("internal symbol");
4358 v
= _("protected symbol");
4366 /* xgettext:c-format */
4367 (_("%B: relocation R_386_GOTOFF against undefined %s"
4368 " `%s' can not be used when making a shared object"),
4369 input_bfd
, v
, h
->root
.root
.string
);
4370 bfd_set_error (bfd_error_bad_value
);
4373 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4374 && (h
->type
== STT_FUNC
4375 || h
->type
== STT_OBJECT
)
4376 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4379 /* xgettext:c-format */
4380 (_("%B: relocation R_386_GOTOFF against protected %s"
4381 " `%s' can not be used when making a shared object"),
4383 h
->type
== STT_FUNC
? "function" : "data",
4384 h
->root
.root
.string
);
4385 bfd_set_error (bfd_error_bad_value
);
4390 /* Note that sgot is not involved in this
4391 calculation. We always want the start of .got.plt. If we
4392 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4393 permitted by the ABI, we might have to change this
4395 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4396 + htab
->elf
.sgotplt
->output_offset
;
4400 /* Use global offset table as symbol value. */
4401 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4402 + htab
->elf
.sgotplt
->output_offset
;
4403 unresolved_reloc
= FALSE
;
4407 /* Relocation is to the entry for this symbol in the
4408 procedure linkage table. */
4410 /* Resolve a PLT32 reloc against a local symbol directly,
4411 without using the procedure linkage table. */
4415 if ((h
->plt
.offset
== (bfd_vma
) -1
4416 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4417 || htab
->elf
.splt
== NULL
)
4419 /* We didn't make a PLT entry for this symbol. This
4420 happens when statically linking PIC code, or when
4421 using -Bsymbolic. */
4425 if (h
->plt
.offset
!= (bfd_vma
) -1)
4427 resolved_plt
= htab
->elf
.splt
;
4428 plt_offset
= h
->plt
.offset
;
4432 resolved_plt
= htab
->plt_got
;
4433 plt_offset
= eh
->plt_got
.offset
;
4436 relocation
= (resolved_plt
->output_section
->vma
4437 + resolved_plt
->output_offset
4439 unresolved_reloc
= FALSE
;
4443 /* Set to symbol size. */
4444 relocation
= st_size
;
4449 if ((input_section
->flags
& SEC_ALLOC
) == 0
4453 /* Copy dynamic function pointer relocations. Don't generate
4454 dynamic relocations against resolved undefined weak symbols
4455 in PIE, except for R_386_PC32. */
4456 if ((bfd_link_pic (info
)
4458 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4459 && (!resolved_to_zero
4460 || r_type
== R_386_PC32
))
4461 || h
->root
.type
!= bfd_link_hash_undefweak
))
4462 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4463 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4464 || (ELIMINATE_COPY_RELOCS
4465 && !bfd_link_pic (info
)
4469 || eh
->func_pointer_refcount
> 0
4470 || (h
->root
.type
== bfd_link_hash_undefweak
4471 && !resolved_to_zero
))
4472 && ((h
->def_dynamic
&& !h
->def_regular
)
4473 /* Undefined weak symbol is bound locally when
4475 || h
->root
.type
== bfd_link_hash_undefweak
)))
4477 Elf_Internal_Rela outrel
;
4478 bfd_boolean skip
, relocate
;
4481 /* When generating a shared object, these relocations
4482 are copied into the output file to be resolved at run
4489 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4491 if (outrel
.r_offset
== (bfd_vma
) -1)
4493 else if (outrel
.r_offset
== (bfd_vma
) -2)
4494 skip
= TRUE
, relocate
= TRUE
;
4495 outrel
.r_offset
+= (input_section
->output_section
->vma
4496 + input_section
->output_offset
);
4499 memset (&outrel
, 0, sizeof outrel
);
4502 && (r_type
== R_386_PC32
4503 || !(bfd_link_executable (info
)
4504 || SYMBOLIC_BIND (info
, h
))
4505 || !h
->def_regular
))
4506 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4509 /* This symbol is local, or marked to become local. */
4511 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4514 sreloc
= elf_section_data (input_section
)->sreloc
;
4516 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4518 r
= bfd_reloc_notsupported
;
4519 goto check_relocation_error
;
4522 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4524 /* If this reloc is against an external symbol, we do
4525 not want to fiddle with the addend. Otherwise, we
4526 need to include the symbol value so that it becomes
4527 an addend for the dynamic reloc. */
4534 if (!bfd_link_executable (info
))
4536 Elf_Internal_Rela outrel
;
4539 outrel
.r_offset
= rel
->r_offset
4540 + input_section
->output_section
->vma
4541 + input_section
->output_offset
;
4542 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4543 sreloc
= elf_section_data (input_section
)->sreloc
;
4546 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4551 case R_386_TLS_GOTDESC
:
4552 case R_386_TLS_DESC_CALL
:
4553 case R_386_TLS_IE_32
:
4554 case R_386_TLS_GOTIE
:
4555 tls_type
= GOT_UNKNOWN
;
4556 if (h
== NULL
&& local_got_offsets
)
4557 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4559 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4560 if (tls_type
== GOT_TLS_IE
)
4561 tls_type
= GOT_TLS_IE_NEG
;
4563 if (! elf_i386_tls_transition (info
, input_bfd
,
4564 input_section
, contents
,
4565 symtab_hdr
, sym_hashes
,
4566 &r_type
, tls_type
, rel
,
4567 relend
, h
, r_symndx
, TRUE
))
4570 if (r_type
== R_386_TLS_LE_32
)
4572 BFD_ASSERT (! unresolved_reloc
);
4573 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4578 /* GD->LE transition. */
4579 type
= *(contents
+ rel
->r_offset
- 2);
4583 leal foo@tlsgd(,%ebx,1), %eax
4584 call ___tls_get_addr@PLT
4587 subl $foo@tpoff, %eax
4588 (6 byte form of subl). */
4589 roff
= rel
->r_offset
+ 5;
4594 leal foo@tlsgd(%ebx), %eax
4595 call ___tls_get_addr@PLT
4598 leal foo@tlsgd(%reg), %eax
4599 call *___tls_get_addr@GOT(%reg)
4600 which may be converted to
4601 addr32 call ___tls_get_addr
4603 movl %gs:0, %eax; subl $foo@tpoff, %eax
4604 (6 byte form of subl). */
4605 roff
= rel
->r_offset
+ 6;
4607 memcpy (contents
+ roff
- 8,
4608 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4609 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4611 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4616 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4618 /* GDesc -> LE transition.
4619 It's originally something like:
4620 leal x@tlsdesc(%ebx), %eax
4624 Registers other than %eax may be set up here. */
4629 roff
= rel
->r_offset
;
4630 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4632 /* Now modify the instruction as appropriate. */
4633 /* aoliva FIXME: remove the above and xor the byte
4635 bfd_put_8 (output_bfd
, val
^ 0x86,
4636 contents
+ roff
- 1);
4637 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4641 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4643 /* GDesc -> LE transition.
4651 roff
= rel
->r_offset
;
4652 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4653 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4656 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4660 /* IE->LE transition:
4661 Originally it can be one of:
4669 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4672 /* movl foo, %eax. */
4673 bfd_put_8 (output_bfd
, 0xb8,
4674 contents
+ rel
->r_offset
- 1);
4680 type
= bfd_get_8 (input_bfd
,
4681 contents
+ rel
->r_offset
- 2);
4686 bfd_put_8 (output_bfd
, 0xc7,
4687 contents
+ rel
->r_offset
- 2);
4688 bfd_put_8 (output_bfd
,
4689 0xc0 | ((val
>> 3) & 7),
4690 contents
+ rel
->r_offset
- 1);
4694 bfd_put_8 (output_bfd
, 0x81,
4695 contents
+ rel
->r_offset
- 2);
4696 bfd_put_8 (output_bfd
,
4697 0xc0 | ((val
>> 3) & 7),
4698 contents
+ rel
->r_offset
- 1);
4705 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4706 contents
+ rel
->r_offset
);
4711 unsigned int val
, type
;
4713 /* {IE_32,GOTIE}->LE transition:
4714 Originally it can be one of:
4715 subl foo(%reg1), %reg2
4716 movl foo(%reg1), %reg2
4717 addl foo(%reg1), %reg2
4720 movl $foo, %reg2 (6 byte form)
4721 addl $foo, %reg2. */
4722 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4723 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4727 bfd_put_8 (output_bfd
, 0xc7,
4728 contents
+ rel
->r_offset
- 2);
4729 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4730 contents
+ rel
->r_offset
- 1);
4732 else if (type
== 0x2b)
4735 bfd_put_8 (output_bfd
, 0x81,
4736 contents
+ rel
->r_offset
- 2);
4737 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4738 contents
+ rel
->r_offset
- 1);
4740 else if (type
== 0x03)
4743 bfd_put_8 (output_bfd
, 0x81,
4744 contents
+ rel
->r_offset
- 2);
4745 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4746 contents
+ rel
->r_offset
- 1);
4750 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4751 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4752 contents
+ rel
->r_offset
);
4754 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4755 contents
+ rel
->r_offset
);
4760 if (htab
->elf
.sgot
== NULL
)
4765 off
= h
->got
.offset
;
4766 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4770 if (local_got_offsets
== NULL
)
4773 off
= local_got_offsets
[r_symndx
];
4774 offplt
= local_tlsdesc_gotents
[r_symndx
];
4781 Elf_Internal_Rela outrel
;
4785 if (htab
->elf
.srelgot
== NULL
)
4788 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4790 if (GOT_TLS_GDESC_P (tls_type
))
4793 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4794 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4795 <= htab
->elf
.sgotplt
->size
);
4796 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4797 + htab
->elf
.sgotplt
->output_offset
4799 + htab
->sgotplt_jump_table_size
);
4800 sreloc
= htab
->elf
.srelplt
;
4801 loc
= sreloc
->contents
;
4802 loc
+= (htab
->next_tls_desc_index
++
4803 * sizeof (Elf32_External_Rel
));
4804 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4805 <= sreloc
->contents
+ sreloc
->size
);
4806 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4809 BFD_ASSERT (! unresolved_reloc
);
4810 bfd_put_32 (output_bfd
,
4811 relocation
- elf_i386_dtpoff_base (info
),
4812 htab
->elf
.sgotplt
->contents
+ offplt
4813 + htab
->sgotplt_jump_table_size
+ 4);
4817 bfd_put_32 (output_bfd
, 0,
4818 htab
->elf
.sgotplt
->contents
+ offplt
4819 + htab
->sgotplt_jump_table_size
+ 4);
4823 sreloc
= htab
->elf
.srelgot
;
4825 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4826 + htab
->elf
.sgot
->output_offset
+ off
);
4828 if (GOT_TLS_GD_P (tls_type
))
4829 dr_type
= R_386_TLS_DTPMOD32
;
4830 else if (GOT_TLS_GDESC_P (tls_type
))
4832 else if (tls_type
== GOT_TLS_IE_POS
)
4833 dr_type
= R_386_TLS_TPOFF
;
4835 dr_type
= R_386_TLS_TPOFF32
;
4837 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4838 bfd_put_32 (output_bfd
,
4839 relocation
- elf_i386_dtpoff_base (info
),
4840 htab
->elf
.sgot
->contents
+ off
);
4841 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4842 bfd_put_32 (output_bfd
,
4843 elf_i386_dtpoff_base (info
) - relocation
,
4844 htab
->elf
.sgot
->contents
+ off
);
4845 else if (dr_type
!= R_386_TLS_DESC
)
4846 bfd_put_32 (output_bfd
, 0,
4847 htab
->elf
.sgot
->contents
+ off
);
4848 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4850 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4852 if (GOT_TLS_GD_P (tls_type
))
4856 BFD_ASSERT (! unresolved_reloc
);
4857 bfd_put_32 (output_bfd
,
4858 relocation
- elf_i386_dtpoff_base (info
),
4859 htab
->elf
.sgot
->contents
+ off
+ 4);
4863 bfd_put_32 (output_bfd
, 0,
4864 htab
->elf
.sgot
->contents
+ off
+ 4);
4865 outrel
.r_info
= ELF32_R_INFO (indx
,
4866 R_386_TLS_DTPOFF32
);
4867 outrel
.r_offset
+= 4;
4868 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4871 else if (tls_type
== GOT_TLS_IE_BOTH
)
4873 bfd_put_32 (output_bfd
,
4875 ? relocation
- elf_i386_dtpoff_base (info
)
4877 htab
->elf
.sgot
->contents
+ off
+ 4);
4878 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4879 outrel
.r_offset
+= 4;
4880 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4887 local_got_offsets
[r_symndx
] |= 1;
4890 if (off
>= (bfd_vma
) -2
4891 && ! GOT_TLS_GDESC_P (tls_type
))
4893 if (r_type
== R_386_TLS_GOTDESC
4894 || r_type
== R_386_TLS_DESC_CALL
)
4896 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4897 unresolved_reloc
= FALSE
;
4899 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4901 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4902 + htab
->elf
.sgotplt
->output_offset
;
4903 relocation
= htab
->elf
.sgot
->output_section
->vma
4904 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4905 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4906 && tls_type
== GOT_TLS_IE_BOTH
)
4908 if (r_type
== R_386_TLS_IE
)
4909 relocation
+= g_o_t
;
4910 unresolved_reloc
= FALSE
;
4912 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4914 unsigned int val
, type
;
4917 /* GD->IE transition. */
4918 type
= *(contents
+ rel
->r_offset
- 2);
4919 val
= *(contents
+ rel
->r_offset
- 1);
4923 leal foo@tlsgd(,%ebx,1), %eax
4924 call ___tls_get_addr@PLT
4927 subl $foo@gottpoff(%ebx), %eax. */
4929 roff
= rel
->r_offset
- 3;
4934 leal foo@tlsgd(%ebx), %eax
4935 call ___tls_get_addr@PLT
4938 leal foo@tlsgd(%reg), %eax
4939 call *___tls_get_addr@GOT(%reg)
4940 which may be converted to
4941 addr32 call ___tls_get_addr
4944 subl $foo@gottpoff(%reg), %eax. */
4945 roff
= rel
->r_offset
- 2;
4947 memcpy (contents
+ roff
,
4948 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4949 contents
[roff
+ 7] = 0x80 | (val
& 7);
4950 /* If foo is used only with foo@gotntpoff(%reg) and
4951 foo@indntpoff, but not with foo@gottpoff(%reg), change
4952 subl $foo@gottpoff(%reg), %eax
4954 addl $foo@gotntpoff(%reg), %eax. */
4955 if (tls_type
== GOT_TLS_IE_POS
)
4956 contents
[roff
+ 6] = 0x03;
4957 bfd_put_32 (output_bfd
,
4958 htab
->elf
.sgot
->output_section
->vma
4959 + htab
->elf
.sgot
->output_offset
+ off
4960 - htab
->elf
.sgotplt
->output_section
->vma
4961 - htab
->elf
.sgotplt
->output_offset
,
4962 contents
+ roff
+ 8);
4963 /* Skip R_386_PLT32 and R_386_GOT32X. */
4968 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4970 /* GDesc -> IE transition.
4971 It's originally something like:
4972 leal x@tlsdesc(%ebx), %eax
4975 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4977 movl x@gottpoff(%ebx), %eax # before negl %eax
4979 Registers other than %eax may be set up here. */
4983 /* First, make sure it's a leal adding ebx to a 32-bit
4984 offset into any register, although it's probably
4985 almost always going to be eax. */
4986 roff
= rel
->r_offset
;
4988 /* Now modify the instruction as appropriate. */
4989 /* To turn a leal into a movl in the form we use it, it
4990 suffices to change the first byte from 0x8d to 0x8b.
4991 aoliva FIXME: should we decide to keep the leal, all
4992 we have to do is remove the statement below, and
4993 adjust the relaxation of R_386_TLS_DESC_CALL. */
4994 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4996 if (tls_type
== GOT_TLS_IE_BOTH
)
4999 bfd_put_32 (output_bfd
,
5000 htab
->elf
.sgot
->output_section
->vma
5001 + htab
->elf
.sgot
->output_offset
+ off
5002 - htab
->elf
.sgotplt
->output_section
->vma
5003 - htab
->elf
.sgotplt
->output_offset
,
5007 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
5009 /* GDesc -> IE transition.
5017 depending on how we transformed the TLS_GOTDESC above.
5022 roff
= rel
->r_offset
;
5024 /* Now modify the instruction as appropriate. */
5025 if (tls_type
!= GOT_TLS_IE_NEG
)
5028 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5029 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5034 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
5035 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
5045 if (! elf_i386_tls_transition (info
, input_bfd
,
5046 input_section
, contents
,
5047 symtab_hdr
, sym_hashes
,
5048 &r_type
, GOT_UNKNOWN
, rel
,
5049 relend
, h
, r_symndx
, TRUE
))
5052 if (r_type
!= R_386_TLS_LDM
)
5054 /* LD->LE transition. Change
5055 leal foo@tlsldm(%ebx) %eax
5056 call ___tls_get_addr@PLT
5060 leal 0(%esi,1), %esi
5062 leal foo@tlsldm(%reg) %eax
5063 call *___tls_get_addr@GOT(%reg)
5064 which may be converted to
5065 addr32 call ___tls_get_addr
5068 leal 0(%esi), %esi */
5069 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
5070 if (*(contents
+ rel
->r_offset
+ 4) == 0xff
5071 || *(contents
+ rel
->r_offset
+ 4) == 0x67)
5072 memcpy (contents
+ rel
->r_offset
- 2,
5073 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5075 memcpy (contents
+ rel
->r_offset
- 2,
5076 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5077 /* Skip R_386_PC32/R_386_PLT32. */
5083 if (htab
->elf
.sgot
== NULL
)
5086 off
= htab
->tls_ldm_got
.offset
;
5091 Elf_Internal_Rela outrel
;
5093 if (htab
->elf
.srelgot
== NULL
)
5096 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5097 + htab
->elf
.sgot
->output_offset
+ off
);
5099 bfd_put_32 (output_bfd
, 0,
5100 htab
->elf
.sgot
->contents
+ off
);
5101 bfd_put_32 (output_bfd
, 0,
5102 htab
->elf
.sgot
->contents
+ off
+ 4);
5103 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
5104 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
5105 htab
->tls_ldm_got
.offset
|= 1;
5107 relocation
= htab
->elf
.sgot
->output_section
->vma
5108 + htab
->elf
.sgot
->output_offset
+ off
5109 - htab
->elf
.sgotplt
->output_section
->vma
5110 - htab
->elf
.sgotplt
->output_offset
;
5111 unresolved_reloc
= FALSE
;
5114 case R_386_TLS_LDO_32
:
5115 if (!bfd_link_executable (info
)
5116 || (input_section
->flags
& SEC_CODE
) == 0)
5117 relocation
-= elf_i386_dtpoff_base (info
);
5119 /* When converting LDO to LE, we must negate. */
5120 relocation
= -elf_i386_tpoff (info
, relocation
);
5123 case R_386_TLS_LE_32
:
5125 if (!bfd_link_executable (info
))
5127 Elf_Internal_Rela outrel
;
5130 outrel
.r_offset
= rel
->r_offset
5131 + input_section
->output_section
->vma
5132 + input_section
->output_offset
;
5133 if (h
!= NULL
&& h
->dynindx
!= -1)
5137 if (r_type
== R_386_TLS_LE_32
)
5138 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
5140 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
5141 sreloc
= elf_section_data (input_section
)->sreloc
;
5144 elf_append_rel (output_bfd
, sreloc
, &outrel
);
5147 else if (r_type
== R_386_TLS_LE_32
)
5148 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
5150 relocation
-= elf_i386_dtpoff_base (info
);
5152 else if (r_type
== R_386_TLS_LE_32
)
5153 relocation
= elf_i386_tpoff (info
, relocation
);
5155 relocation
= -elf_i386_tpoff (info
, relocation
);
5162 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5163 because such sections are not SEC_ALLOC and thus ld.so will
5164 not process them. */
5165 if (unresolved_reloc
5166 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5168 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5169 rel
->r_offset
) != (bfd_vma
) -1)
5172 /* xgettext:c-format */
5173 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5176 (long) rel
->r_offset
,
5178 h
->root
.root
.string
);
5183 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5184 contents
, rel
->r_offset
,
5187 check_relocation_error
:
5188 if (r
!= bfd_reloc_ok
)
5193 name
= h
->root
.root
.string
;
5196 name
= bfd_elf_string_from_elf_section (input_bfd
,
5197 symtab_hdr
->sh_link
,
5202 name
= bfd_section_name (input_bfd
, sec
);
5205 if (r
== bfd_reloc_overflow
)
5206 (*info
->callbacks
->reloc_overflow
)
5207 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5208 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5212 /* xgettext:c-format */
5213 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5214 input_bfd
, input_section
,
5215 (long) rel
->r_offset
, name
, (int) r
);
5226 Elf_Internal_Shdr
*rel_hdr
;
5227 size_t deleted
= rel
- wrel
;
5229 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5230 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5231 if (rel_hdr
->sh_size
== 0)
5233 /* It is too late to remove an empty reloc section. Leave
5235 ??? What is wrong with an empty section??? */
5236 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5239 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5240 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5241 input_section
->reloc_count
-= deleted
;
5247 /* Finish up dynamic symbol handling. We set the contents of various
5248 dynamic sections here. */
5251 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5252 struct bfd_link_info
*info
,
5253 struct elf_link_hash_entry
*h
,
5254 Elf_Internal_Sym
*sym
)
5256 struct elf_i386_link_hash_table
*htab
;
5257 unsigned plt_entry_size
;
5258 const struct elf_i386_backend_data
*abed
;
5259 struct elf_i386_link_hash_entry
*eh
;
5260 bfd_boolean local_undefweak
;
5262 htab
= elf_i386_hash_table (info
);
5266 abed
= get_elf_i386_backend_data (output_bfd
);
5267 plt_entry_size
= htab
->plt
.plt_entry_size
;
5269 eh
= (struct elf_i386_link_hash_entry
*) h
;
5270 if (eh
->no_finish_dynamic_symbol
)
5273 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5274 resolved undefined weak symbols in executable so that their
5275 references have value 0 at run-time. */
5276 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5280 if (h
->plt
.offset
!= (bfd_vma
) -1)
5284 Elf_Internal_Rela rel
;
5286 asection
*plt
, *gotplt
, *relplt
;
5288 /* When building a static executable, use .iplt, .igot.plt and
5289 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5290 if (htab
->elf
.splt
!= NULL
)
5292 plt
= htab
->elf
.splt
;
5293 gotplt
= htab
->elf
.sgotplt
;
5294 relplt
= htab
->elf
.srelplt
;
5298 plt
= htab
->elf
.iplt
;
5299 gotplt
= htab
->elf
.igotplt
;
5300 relplt
= htab
->elf
.irelplt
;
5303 /* This symbol has an entry in the procedure linkage table. Set
5306 if ((h
->dynindx
== -1
5308 && !((h
->forced_local
|| bfd_link_executable (info
))
5310 && h
->type
== STT_GNU_IFUNC
))
5316 /* Get the index in the procedure linkage table which
5317 corresponds to this symbol. This is the index of this symbol
5318 in all the symbols for which we are making plt entries. The
5319 first entry in the procedure linkage table is reserved.
5321 Get the offset into the .got table of the entry that
5322 corresponds to this function. Each .got entry is 4 bytes.
5323 The first three are reserved.
5325 For static executables, we don't reserve anything. */
5327 if (plt
== htab
->elf
.splt
)
5329 got_offset
= (h
->plt
.offset
/ plt_entry_size
5330 - htab
->plt
.has_plt0
);
5331 got_offset
= (got_offset
+ 3) * 4;
5335 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5336 got_offset
= got_offset
* 4;
5339 /* Fill in the entry in the procedure linkage table and update
5341 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
5343 if (! bfd_link_pic (info
))
5345 bfd_put_32 (output_bfd
,
5346 (gotplt
->output_section
->vma
5347 + gotplt
->output_offset
5349 plt
->contents
+ h
->plt
.offset
5350 + htab
->plt
.plt_got_offset
);
5352 if (abed
->os
== is_vxworks
)
5354 int s
, k
, reloc_index
;
5356 /* Create the R_386_32 relocation referencing the GOT
5357 for this PLT entry. */
5359 /* S: Current slot number (zero-based). */
5360 s
= ((h
->plt
.offset
- htab
->plt
.plt_entry_size
)
5361 / htab
->plt
.plt_entry_size
);
5362 /* K: Number of relocations for PLTResolve. */
5363 if (bfd_link_pic (info
))
5364 k
= PLTRESOLVE_RELOCS_SHLIB
;
5366 k
= PLTRESOLVE_RELOCS
;
5367 /* Skip the PLTresolve relocations, and the relocations for
5368 the other PLT slots. */
5369 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5370 loc
= (htab
->srelplt2
->contents
+ reloc_index
5371 * sizeof (Elf32_External_Rel
));
5373 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5374 + htab
->elf
.splt
->output_offset
5375 + h
->plt
.offset
+ 2),
5376 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5377 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5379 /* Create the R_386_32 relocation referencing the beginning of
5380 the PLT for this GOT entry. */
5381 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5382 + htab
->elf
.sgotplt
->output_offset
5384 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5385 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5386 loc
+ sizeof (Elf32_External_Rel
));
5391 bfd_put_32 (output_bfd
, got_offset
,
5392 plt
->contents
+ h
->plt
.offset
5393 + htab
->plt
.plt_got_offset
);
5396 /* Fill in the entry in the global offset table. Leave the entry
5397 as zero for undefined weak symbol in PIE. No PLT relocation
5398 against undefined weak symbol in PIE. */
5399 if (!local_undefweak
)
5401 if (htab
->plt
.has_plt0
)
5402 bfd_put_32 (output_bfd
,
5403 (plt
->output_section
->vma
5404 + plt
->output_offset
5406 + htab
->lazy_plt
->plt_lazy_offset
),
5407 gotplt
->contents
+ got_offset
);
5409 /* Fill in the entry in the .rel.plt section. */
5410 rel
.r_offset
= (gotplt
->output_section
->vma
5411 + gotplt
->output_offset
5413 if (h
->dynindx
== -1
5414 || ((bfd_link_executable (info
)
5415 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5417 && h
->type
== STT_GNU_IFUNC
))
5419 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
5420 h
->root
.root
.string
,
5421 h
->root
.u
.def
.section
->owner
);
5423 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5424 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5425 in the .got.plt section. */
5426 bfd_put_32 (output_bfd
,
5427 (h
->root
.u
.def
.value
5428 + h
->root
.u
.def
.section
->output_section
->vma
5429 + h
->root
.u
.def
.section
->output_offset
),
5430 gotplt
->contents
+ got_offset
);
5431 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5432 /* R_386_IRELATIVE comes last. */
5433 plt_index
= htab
->next_irelative_index
--;
5437 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5438 plt_index
= htab
->next_jump_slot_index
++;
5441 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5442 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5444 /* Don't fill the second and third slots in PLT entry for
5445 static executables nor without PLT0. */
5446 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
5448 bfd_put_32 (output_bfd
,
5449 plt_index
* sizeof (Elf32_External_Rel
),
5450 plt
->contents
+ h
->plt
.offset
5451 + htab
->lazy_plt
->plt_reloc_offset
);
5452 bfd_put_32 (output_bfd
,
5454 + htab
->lazy_plt
->plt_plt_offset
+ 4),
5455 (plt
->contents
+ h
->plt
.offset
5456 + htab
->lazy_plt
->plt_plt_offset
));
5460 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5462 bfd_vma got_offset
, plt_offset
;
5463 asection
*plt
, *got
, *gotplt
;
5464 const bfd_byte
*got_plt_entry
;
5466 /* Set the entry in the GOT procedure linkage table. */
5467 plt
= htab
->plt_got
;
5468 got
= htab
->elf
.sgot
;
5469 gotplt
= htab
->elf
.sgotplt
;
5470 got_offset
= h
->got
.offset
;
5472 if (got_offset
== (bfd_vma
) -1
5478 /* Fill in the entry in the GOT procedure linkage table. */
5479 if (! bfd_link_pic (info
))
5481 got_plt_entry
= htab
->non_lazy_plt
->plt_entry
;
5482 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5486 got_plt_entry
= htab
->non_lazy_plt
->pic_plt_entry
;
5487 got_offset
+= (got
->output_section
->vma
5488 + got
->output_offset
5489 - gotplt
->output_section
->vma
5490 - gotplt
->output_offset
);
5493 plt_offset
= eh
->plt_got
.offset
;
5494 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5495 htab
->non_lazy_plt
->plt_entry_size
);
5496 bfd_put_32 (output_bfd
, got_offset
,
5497 (plt
->contents
+ plt_offset
5498 + htab
->non_lazy_plt
->plt_got_offset
));
5501 if (!local_undefweak
5503 && (h
->plt
.offset
!= (bfd_vma
) -1
5504 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5506 /* Mark the symbol as undefined, rather than as defined in
5507 the .plt section. Leave the value if there were any
5508 relocations where pointer equality matters (this is a clue
5509 for the dynamic linker, to make function pointer
5510 comparisons work between an application and shared
5511 library), otherwise set it to zero. If a function is only
5512 called from a binary, there is no need to slow down
5513 shared libraries because of that. */
5514 sym
->st_shndx
= SHN_UNDEF
;
5515 if (!h
->pointer_equality_needed
)
5519 /* Don't generate dynamic GOT relocation against undefined weak
5520 symbol in executable. */
5521 if (h
->got
.offset
!= (bfd_vma
) -1
5522 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5523 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5524 && !local_undefweak
)
5526 Elf_Internal_Rela rel
;
5527 asection
*relgot
= htab
->elf
.srelgot
;
5529 /* This symbol has an entry in the global offset table. Set it
5532 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5535 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5536 + htab
->elf
.sgot
->output_offset
5537 + (h
->got
.offset
& ~(bfd_vma
) 1));
5539 /* If this is a static link, or it is a -Bsymbolic link and the
5540 symbol is defined locally or was forced to be local because
5541 of a version file, we just want to emit a RELATIVE reloc.
5542 The entry in the global offset table will already have been
5543 initialized in the relocate_section function. */
5545 && h
->type
== STT_GNU_IFUNC
)
5547 if (h
->plt
.offset
== (bfd_vma
) -1)
5549 /* STT_GNU_IFUNC is referenced without PLT. */
5550 if (htab
->elf
.splt
== NULL
)
5552 /* use .rel[a].iplt section to store .got relocations
5553 in static executable. */
5554 relgot
= htab
->elf
.irelplt
;
5556 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5558 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
5559 h
->root
.root
.string
,
5560 h
->root
.u
.def
.section
->owner
);
5562 bfd_put_32 (output_bfd
,
5563 (h
->root
.u
.def
.value
5564 + h
->root
.u
.def
.section
->output_section
->vma
5565 + h
->root
.u
.def
.section
->output_offset
),
5566 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5567 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5572 else if (bfd_link_pic (info
))
5574 /* Generate R_386_GLOB_DAT. */
5581 if (!h
->pointer_equality_needed
)
5584 /* For non-shared object, we can't use .got.plt, which
5585 contains the real function addres if we need pointer
5586 equality. We load the GOT entry with the PLT entry. */
5587 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5588 bfd_put_32 (output_bfd
,
5589 (plt
->output_section
->vma
5590 + plt
->output_offset
+ h
->plt
.offset
),
5591 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5595 else if (bfd_link_pic (info
)
5596 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5598 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5599 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5603 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5605 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5606 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5607 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5610 elf_append_rel (output_bfd
, relgot
, &rel
);
5615 Elf_Internal_Rela rel
;
5618 /* This symbol needs a copy reloc. Set it up. */
5620 if (h
->dynindx
== -1
5621 || (h
->root
.type
!= bfd_link_hash_defined
5622 && h
->root
.type
!= bfd_link_hash_defweak
)
5623 || htab
->elf
.srelbss
== NULL
5624 || htab
->elf
.sreldynrelro
== NULL
)
5627 rel
.r_offset
= (h
->root
.u
.def
.value
5628 + h
->root
.u
.def
.section
->output_section
->vma
5629 + h
->root
.u
.def
.section
->output_offset
);
5630 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5631 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
5632 s
= htab
->elf
.sreldynrelro
;
5634 s
= htab
->elf
.srelbss
;
5635 elf_append_rel (output_bfd
, s
, &rel
);
5641 /* Finish up local dynamic symbol handling. We set the contents of
5642 various dynamic sections here. */
5645 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5647 struct elf_link_hash_entry
*h
5648 = (struct elf_link_hash_entry
*) *slot
;
5649 struct bfd_link_info
*info
5650 = (struct bfd_link_info
*) inf
;
5652 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5656 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5657 here since undefined weak symbol may not be dynamic and may not be
5658 called for elf_i386_finish_dynamic_symbol. */
5661 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5664 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5665 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5667 if (h
->root
.type
!= bfd_link_hash_undefweak
5668 || h
->dynindx
!= -1)
5671 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5675 /* Used to decide how to sort relocs in an optimal manner for the
5676 dynamic linker, before writing them out. */
5678 static enum elf_reloc_type_class
5679 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5680 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5681 const Elf_Internal_Rela
*rela
)
5683 bfd
*abfd
= info
->output_bfd
;
5684 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5685 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5687 if (htab
->dynsym
!= NULL
5688 && htab
->dynsym
->contents
!= NULL
)
5690 /* Check relocation against STT_GNU_IFUNC symbol if there are
5692 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5693 if (r_symndx
!= STN_UNDEF
)
5695 Elf_Internal_Sym sym
;
5696 if (!bed
->s
->swap_symbol_in (abfd
,
5697 (htab
->dynsym
->contents
5698 + r_symndx
* sizeof (Elf32_External_Sym
)),
5702 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5703 return reloc_class_ifunc
;
5707 switch (ELF32_R_TYPE (rela
->r_info
))
5709 case R_386_IRELATIVE
:
5710 return reloc_class_ifunc
;
5711 case R_386_RELATIVE
:
5712 return reloc_class_relative
;
5713 case R_386_JUMP_SLOT
:
5714 return reloc_class_plt
;
5716 return reloc_class_copy
;
5718 return reloc_class_normal
;
5722 /* Finish up the dynamic sections. */
5725 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5726 struct bfd_link_info
*info
)
5728 struct elf_i386_link_hash_table
*htab
;
5731 const struct elf_i386_backend_data
*abed
;
5733 htab
= elf_i386_hash_table (info
);
5737 dynobj
= htab
->elf
.dynobj
;
5738 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5739 abed
= get_elf_i386_backend_data (output_bfd
);
5741 if (htab
->elf
.dynamic_sections_created
)
5743 Elf32_External_Dyn
*dyncon
, *dynconend
;
5745 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5748 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5749 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5750 for (; dyncon
< dynconend
; dyncon
++)
5752 Elf_Internal_Dyn dyn
;
5755 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5760 if (abed
->os
== is_vxworks
5761 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5766 s
= htab
->elf
.sgotplt
;
5767 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5771 s
= htab
->elf
.srelplt
;
5772 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5776 s
= htab
->elf
.srelplt
;
5777 dyn
.d_un
.d_val
= s
->size
;
5781 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5784 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5786 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5787 really seem like the right value. */
5788 elf_section_data (htab
->elf
.splt
->output_section
)
5789 ->this_hdr
.sh_entsize
= 4;
5791 if (htab
->plt
.has_plt0
)
5793 /* Fill in the special first entry in the procedure linkage
5795 memcpy (htab
->elf
.splt
->contents
, htab
->plt
.plt0_entry
,
5796 htab
->lazy_plt
->plt0_entry_size
);
5797 memset (htab
->elf
.splt
->contents
+ htab
->lazy_plt
->plt0_entry_size
,
5798 abed
->plt0_pad_byte
,
5799 htab
->plt
.plt_entry_size
- htab
->lazy_plt
->plt0_entry_size
);
5800 if (!bfd_link_pic (info
))
5802 bfd_put_32 (output_bfd
,
5803 (htab
->elf
.sgotplt
->output_section
->vma
5804 + htab
->elf
.sgotplt
->output_offset
5806 htab
->elf
.splt
->contents
5807 + htab
->lazy_plt
->plt0_got1_offset
);
5808 bfd_put_32 (output_bfd
,
5809 (htab
->elf
.sgotplt
->output_section
->vma
5810 + htab
->elf
.sgotplt
->output_offset
5812 htab
->elf
.splt
->contents
5813 + htab
->lazy_plt
->plt0_got2_offset
);
5815 if (abed
->os
== is_vxworks
)
5817 Elf_Internal_Rela rel
;
5818 int num_plts
= (htab
->elf
.splt
->size
5819 / htab
->plt
.plt_entry_size
) - 1;
5822 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5823 + 4. On IA32 we use REL relocations so the
5824 addend goes in the PLT directly. */
5825 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5826 + htab
->elf
.splt
->output_offset
5827 + htab
->lazy_plt
->plt0_got1_offset
);
5828 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5830 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5831 htab
->srelplt2
->contents
);
5832 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5834 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5835 + htab
->elf
.splt
->output_offset
5836 + htab
->lazy_plt
->plt0_got2_offset
);
5837 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5839 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5840 htab
->srelplt2
->contents
+
5841 sizeof (Elf32_External_Rel
));
5842 /* Correct the .rel.plt.unloaded relocations. */
5843 p
= htab
->srelplt2
->contents
;
5844 if (bfd_link_pic (info
))
5845 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5847 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5849 for (; num_plts
; num_plts
--)
5851 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5852 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
,
5854 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5855 p
+= sizeof (Elf32_External_Rel
);
5857 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5858 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
,
5860 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5861 p
+= sizeof (Elf32_External_Rel
);
5868 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
5869 elf_section_data (htab
->plt_got
->output_section
)
5870 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
5873 /* Fill in the first three entries in the global offset table. */
5874 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
5876 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5879 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5883 bfd_put_32 (output_bfd
,
5885 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5886 htab
->elf
.sgotplt
->contents
);
5887 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5888 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5890 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5893 /* Adjust .eh_frame for .plt section. */
5894 if (htab
->plt_eh_frame
!= NULL
5895 && htab
->plt_eh_frame
->contents
!= NULL
)
5897 if (htab
->elf
.splt
!= NULL
5898 && htab
->elf
.splt
->size
!= 0
5899 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5900 && htab
->elf
.splt
->output_section
!= NULL
5901 && htab
->plt_eh_frame
->output_section
!= NULL
)
5903 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5904 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5905 + htab
->plt_eh_frame
->output_offset
5906 + PLT_FDE_START_OFFSET
;
5907 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5908 htab
->plt_eh_frame
->contents
5909 + PLT_FDE_START_OFFSET
);
5911 if (htab
->plt_eh_frame
->sec_info_type
5912 == SEC_INFO_TYPE_EH_FRAME
)
5914 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5916 htab
->plt_eh_frame
->contents
))
5921 /* Adjust .eh_frame for .plt.got section. */
5922 if (htab
->plt_got_eh_frame
!= NULL
5923 && htab
->plt_got_eh_frame
->contents
!= NULL
)
5925 if (htab
->plt_got
!= NULL
5926 && htab
->plt_got
->size
!= 0
5927 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
5928 && htab
->plt_got
->output_section
!= NULL
5929 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
5931 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
5932 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
5933 + htab
->plt_got_eh_frame
->output_offset
5934 + PLT_FDE_START_OFFSET
;
5935 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5936 htab
->plt_got_eh_frame
->contents
5937 + PLT_FDE_START_OFFSET
);
5939 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5941 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5942 htab
->plt_got_eh_frame
,
5943 htab
->plt_got_eh_frame
->contents
))
5948 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5949 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5951 /* Fill PLT entries for undefined weak symbols in PIE. */
5952 if (bfd_link_pie (info
))
5953 bfd_hash_traverse (&info
->hash
->table
,
5954 elf_i386_pie_finish_undefweak_symbol
,
5960 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5961 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5962 It has to be done before elf_link_sort_relocs is called so that
5963 dynamic relocations are properly sorted. */
5966 elf_i386_output_arch_local_syms
5967 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5968 struct bfd_link_info
*info
,
5969 void *flaginfo ATTRIBUTE_UNUSED
,
5970 int (*func
) (void *, const char *,
5973 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5975 struct elf_i386_link_hash_table
*htab
= elf_i386_hash_table (info
);
5979 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5980 htab_traverse (htab
->loc_hash_table
,
5981 elf_i386_finish_local_dynamic_symbol
,
5987 /* Sort relocs into address order. */
5990 compare_relocs (const void *ap
, const void *bp
)
5992 const arelent
*a
= * (const arelent
**) ap
;
5993 const arelent
*b
= * (const arelent
**) bp
;
5995 if (a
->address
> b
->address
)
5997 else if (a
->address
< b
->address
)
6003 enum elf_i386_plt_type
6016 enum elf_i386_plt_type type
;
6017 unsigned int plt_got_offset
;
6018 unsigned int plt_entry_size
;
6022 /* Forward declaration. */
6023 static const struct elf_i386_lazy_plt_layout elf_i386_nacl_plt
;
6025 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
6026 dynamic relocations. */
6029 elf_i386_get_synthetic_symtab (bfd
*abfd
,
6030 long symcount ATTRIBUTE_UNUSED
,
6031 asymbol
**syms ATTRIBUTE_UNUSED
,
6036 long size
, count
, i
, n
;
6038 unsigned int plt_got_offset
, plt_entry_size
;
6040 bfd_byte
*plt_contents
;
6041 long dynrelcount
, relsize
;
6042 arelent
**dynrelbuf
;
6043 const struct elf_i386_lazy_plt_layout
*lazy_plt
;
6044 const struct elf_i386_non_lazy_plt_layout
*non_lazy_plt
;
6048 enum elf_i386_plt_type plt_type
;
6049 struct elf_i386_plt plts
[] =
6051 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0 },
6052 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0 },
6053 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0 }
6058 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
6061 if (dynsymcount
<= 0)
6064 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
6068 dynrelbuf
= (arelent
**) bfd_malloc (relsize
);
6069 if (dynrelbuf
== NULL
)
6072 dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
, dynrelbuf
,
6075 /* Sort the relocs by address. */
6076 qsort (dynrelbuf
, dynrelcount
, sizeof (arelent
*), compare_relocs
);
6078 non_lazy_plt
= NULL
;
6079 /* Silence GCC 6. */
6081 switch (get_elf_i386_backend_data (abfd
)->os
)
6084 non_lazy_plt
= &elf_i386_non_lazy_plt
;
6087 lazy_plt
= &elf_i386_lazy_plt
;
6090 lazy_plt
= &elf_i386_nacl_plt
;
6097 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6099 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
6103 /* Get the PLT section contents. */
6104 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6105 if (plt_contents
== NULL
)
6107 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6108 plt_contents
, 0, plt
->size
))
6110 free (plt_contents
);
6114 /* Check what kind of PLT it is. */
6115 plt_type
= plt_unknown
;
6116 if (plts
[j
].type
== plt_unknown
)
6118 /* Match lazy PLT first. */
6119 if (memcmp (plt_contents
, lazy_plt
->plt0_entry
,
6120 lazy_plt
->plt0_got1_offset
) == 0)
6121 plt_type
= plt_lazy
;
6122 else if (memcmp (plt_contents
, lazy_plt
->pic_plt0_entry
,
6123 lazy_plt
->plt0_got1_offset
) == 0)
6124 plt_type
= plt_lazy
| plt_pic
;
6127 if (non_lazy_plt
!= NULL
6128 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
))
6130 /* Match non-lazy PLT. */
6131 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
6132 non_lazy_plt
->plt_got_offset
) == 0)
6133 plt_type
= plt_non_lazy
;
6134 else if (memcmp (plt_contents
, non_lazy_plt
->pic_plt_entry
,
6135 non_lazy_plt
->plt_got_offset
) == 0)
6139 if (plt_type
== plt_unknown
)
6143 plts
[j
].type
= plt_type
;
6145 if ((plt_type
& plt_lazy
))
6147 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
6148 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
6149 /* Skip PLT0 in lazy PLT. */
6154 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
6155 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
6159 n
= plt
->size
/ plts
[j
].plt_entry_size
;
6163 plts
[j
].contents
= plt_contents
;
6165 /* The _GLOBAL_OFFSET_TABLE_ address is needed. */
6166 if ((plt_type
& plt_pic
))
6167 got_addr
= (bfd_vma
) -1;
6170 size
= count
* sizeof (asymbol
);
6171 s
= *ret
= (asymbol
*) bfd_zmalloc (size
);
6175 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6176 if (plts
[j
].contents
!= NULL
)
6177 free (plts
[j
].contents
);
6184 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
6186 asection
*sec
= bfd_get_section_by_name (abfd
, ".got.plt");
6188 got_addr
= sec
->vma
;
6191 sec
= bfd_get_section_by_name (abfd
, ".got");
6193 got_addr
= sec
->vma
;
6196 if (got_addr
== (bfd_vma
) -1)
6200 /* Check for each PLT section. */
6203 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6204 if ((plt_contents
= plts
[j
].contents
) != NULL
)
6209 plt_got_offset
= plts
[j
].plt_got_offset
;
6210 plt_entry_size
= plts
[j
].plt_entry_size
;
6214 if ((plts
[j
].type
& plt_lazy
))
6216 /* Skip PLT0 in lazy PLT. */
6218 offset
= plt_entry_size
;
6226 /* Check each PLT entry against dynamic relocations. */
6227 for (; k
< plts
[j
].count
; k
++)
6234 /* Get the GOT offset, a signed 32-bit integer. */
6235 off
= H_GET_32 (abfd
, (plt_contents
+ offset
6237 got_vma
= got_addr
+ off
;
6239 /* Binary search. */
6243 while ((min
+ 1) < max
)
6247 mid
= (min
+ max
) / 2;
6249 if (got_vma
> r
->address
)
6251 else if (got_vma
< r
->address
)
6260 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6261 if (got_vma
== p
->address
6263 && (p
->howto
->type
== R_386_JUMP_SLOT
6264 || p
->howto
->type
== R_386_GLOB_DAT
6265 || p
->howto
->type
== R_386_IRELATIVE
))
6267 *s
= **p
->sym_ptr_ptr
;
6268 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6269 set. Since we are defining a symbol, ensure one
6271 if ((s
->flags
& BSF_LOCAL
) == 0)
6272 s
->flags
|= BSF_GLOBAL
;
6273 s
->flags
|= BSF_SYNTHETIC
;
6274 /* This is no longer a section symbol. */
6275 s
->flags
&= ~BSF_SECTION_SYM
;
6277 s
->the_bfd
= plt
->owner
;
6279 /* Store relocation for later use. */
6281 /* Add @plt to function name later. */
6282 size
+= strlen (s
->name
) + sizeof ("@plt");
6284 size
+= sizeof ("+0x") - 1 + 8;
6288 offset
+= plt_entry_size
;
6292 /* PLT entries with R_386_TLS_DESC relocations are skipped. */
6298 /* Allocate space for @plt suffixes. */
6299 names
= (char *) bfd_malloc (size
);
6304 for (i
= 0; i
< count
; i
++)
6306 /* Add @plt to function name. */
6307 arelent
*p
= (arelent
*) s
->udata
.p
;
6310 size
= strlen (s
->name
);
6311 memcpy (names
, s
->name
, size
);
6318 memcpy (names
, "+0x", sizeof ("+0x") - 1);
6319 names
+= sizeof ("+0x") - 1;
6320 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
6321 for (a
= buf
; *a
== '0'; ++a
)
6324 memcpy (names
, a
, size
);
6327 memcpy (names
, "@plt", sizeof ("@plt"));
6328 names
+= sizeof ("@plt");
6332 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
6333 if (plts
[j
].contents
!= NULL
)
6334 free (plts
[j
].contents
);
6341 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6344 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
6346 if (h
->plt
.offset
!= (bfd_vma
) -1
6348 && !h
->pointer_equality_needed
)
6351 return _bfd_elf_hash_symbol (h
);
6354 /* Parse i386 GNU properties. */
6356 static enum elf_property_kind
6357 elf_i386_parse_gnu_properties (bfd
*abfd
, unsigned int type
,
6358 bfd_byte
*ptr
, unsigned int datasz
)
6364 case GNU_PROPERTY_X86_ISA_1_USED
:
6365 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
6369 ((type
== GNU_PROPERTY_X86_ISA_1_USED
6370 ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
6371 : _("error: %B: <corrupt x86 ISA needed size: 0x%x>")),
6373 return property_corrupt
;
6375 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
6376 /* Combine properties of the same type. */
6377 prop
->u
.number
|= bfd_h_get_32 (abfd
, ptr
);
6378 prop
->pr_kind
= property_number
;
6382 return property_ignored
;
6385 return property_number
;
6388 /* Merge i386 GNU property BPROP with APROP. If APROP isn't NULL,
6389 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP
6390 should be merged with ABFD. */
6393 elf_i386_merge_gnu_properties (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6394 bfd
*abfd ATTRIBUTE_UNUSED
,
6395 elf_property
*aprop
,
6396 elf_property
*bprop
)
6398 unsigned int number
;
6399 bfd_boolean updated
= FALSE
;
6400 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
6404 case GNU_PROPERTY_X86_ISA_1_USED
:
6405 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
6406 if (aprop
!= NULL
&& bprop
!= NULL
)
6408 number
= aprop
->u
.number
;
6409 aprop
->u
.number
= number
| bprop
->u
.number
;
6410 updated
= number
!= (unsigned int) aprop
->u
.number
;
6414 /* Return TRUE if APROP is NULL to indicate that BPROP should
6415 be added to ABFD. */
6416 updated
= aprop
== NULL
;
6421 /* Never should happen. */
6428 /* Set up i386 GNU properties. Return the first relocatable ELF input
6429 with GNU properties if found. Otherwise, return NULL. */
6432 elf_i386_link_setup_gnu_properties (struct bfd_link_info
*info
)
6434 bfd_boolean normal_target
;
6435 asection
*sec
, *pltsec
;
6437 unsigned int plt_alignment
;
6438 struct elf_i386_link_hash_table
*htab
;
6439 bfd
*pbfd
= _bfd_elf_link_setup_gnu_properties (info
);
6441 if (bfd_link_relocatable (info
))
6444 htab
= elf_i386_hash_table (info
);
6448 dynobj
= htab
->elf
.dynobj
;
6450 /* Set htab->elf.dynobj here so that there is no need to check and
6451 set it in check_relocs. */
6456 /* Find a normal input file to hold linker created
6458 for (abfd
= info
->input_bfds
;
6460 abfd
= abfd
->link
.next
)
6462 & (DYNAMIC
| BFD_LINKER_CREATED
| BFD_PLUGIN
)) == 0)
6464 htab
->elf
.dynobj
= abfd
;
6470 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
6471 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
6472 canonical function address. */
6473 htab
->plt
.has_plt0
= 1;
6474 normal_target
= FALSE
;
6476 switch (get_elf_i386_backend_data (info
->output_bfd
)->os
)
6479 htab
->lazy_plt
= &elf_i386_lazy_plt
;
6480 htab
->non_lazy_plt
= &elf_i386_non_lazy_plt
;
6481 normal_target
= TRUE
;
6484 htab
->lazy_plt
= &elf_i386_lazy_plt
;
6485 htab
->non_lazy_plt
= NULL
;
6486 if (!elf_vxworks_create_dynamic_sections (dynobj
, info
,
6488 info
->callbacks
->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
6491 htab
->lazy_plt
= &elf_i386_nacl_plt
;
6492 htab
->non_lazy_plt
= NULL
;
6496 pltsec
= htab
->elf
.splt
;
6498 /* If the non-lazy PLT is available, use it for all PLT entries if
6499 there are no PLT0 or no .plt section. */
6500 if (htab
->non_lazy_plt
!= NULL
6501 && (!htab
->plt
.has_plt0
|| pltsec
== NULL
))
6503 if (bfd_link_pic (info
))
6505 = htab
->non_lazy_plt
->pic_plt_entry
;
6508 = htab
->non_lazy_plt
->plt_entry
;
6509 htab
->plt
.plt_entry_size
6510 = htab
->non_lazy_plt
->plt_entry_size
;
6511 htab
->plt
.plt_got_offset
6512 = htab
->non_lazy_plt
->plt_got_offset
;
6513 htab
->plt
.eh_frame_plt_size
6514 = htab
->non_lazy_plt
->eh_frame_plt_size
;
6515 htab
->plt
.eh_frame_plt
6516 = htab
->non_lazy_plt
->eh_frame_plt
;
6520 if (bfd_link_pic (info
))
6522 htab
->plt
.plt0_entry
6523 = htab
->lazy_plt
->pic_plt0_entry
;
6525 = htab
->lazy_plt
->pic_plt_entry
;
6529 htab
->plt
.plt0_entry
6530 = htab
->lazy_plt
->plt0_entry
;
6532 = htab
->lazy_plt
->plt_entry
;
6534 htab
->plt
.plt_entry_size
6535 = htab
->lazy_plt
->plt_entry_size
;
6536 htab
->plt
.plt_got_offset
6537 = htab
->lazy_plt
->plt_got_offset
;
6538 htab
->plt
.eh_frame_plt_size
6539 = htab
->lazy_plt
->eh_frame_plt_size
;
6540 htab
->plt
.eh_frame_plt
6541 = htab
->lazy_plt
->eh_frame_plt
;
6544 /* Return if there are no normal input files. */
6548 /* Since create_dynamic_sections isn't always called, but GOT
6549 relocations need GOT relocations, create them here so that we
6550 don't need to do it in check_relocs. */
6551 if (htab
->elf
.sgot
== NULL
6552 && !_bfd_elf_create_got_section (dynobj
, info
))
6553 info
->callbacks
->einfo (_("%F: failed to create GOT sections\n"));
6555 /* Create the ifunc sections here so that check_relocs can be
6557 if (!_bfd_elf_create_ifunc_sections (dynobj
, info
))
6558 info
->callbacks
->einfo (_("%F: failed to create ifunc sections\n"));
6560 plt_alignment
= bfd_log2 (htab
->plt
.plt_entry_size
);
6564 /* Whe creating executable, set the contents of the .interp
6565 section to the interpreter. */
6566 if (bfd_link_executable (info
) && !info
->nointerp
)
6568 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
6571 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
6572 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
6576 /* Don't change PLT section alignment for NaCl since it uses
6577 64-byte PLT entry and sets PLT section alignment to 32
6581 const struct elf_backend_data
*bed
6582 = get_elf_backend_data (dynobj
);
6583 flagword pltflags
= (bed
->dynamic_sec_flags
6588 unsigned int non_lazy_plt_alignment
6589 = bfd_log2 (htab
->non_lazy_plt
->plt_entry_size
);
6592 if (!bfd_set_section_alignment (sec
->owner
, sec
,
6594 goto error_alignment
;
6596 /* Create the GOT procedure linkage table. */
6597 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6601 info
->callbacks
->einfo (_("%F: failed to create GOT PLT section\n"));
6603 if (!bfd_set_section_alignment (dynobj
, sec
,
6604 non_lazy_plt_alignment
))
6605 goto error_alignment
;
6607 htab
->plt_got
= sec
;
6610 if (!info
->no_ld_generated_unwind_info
)
6612 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
6613 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6614 | SEC_LINKER_CREATED
);
6616 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6620 info
->callbacks
->einfo (_("%F: failed to create PLT .eh_frame section\n"));
6622 if (!bfd_set_section_alignment (dynobj
, sec
, 2))
6623 goto error_alignment
;
6625 htab
->plt_eh_frame
= sec
;
6627 if (htab
->plt_got
!= NULL
)
6629 sec
= bfd_make_section_anyway_with_flags (dynobj
,
6633 info
->callbacks
->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
6635 if (!bfd_set_section_alignment (dynobj
, sec
, 2))
6636 goto error_alignment
;
6638 htab
->plt_got_eh_frame
= sec
;
6645 /* The .iplt section is used for IFUNC symbols in static
6647 sec
= htab
->elf
.iplt
;
6649 && !bfd_set_section_alignment (sec
->owner
, sec
,
6653 info
->callbacks
->einfo (_("%F%A: failed to align section\n"),
6661 #define TARGET_LITTLE_SYM i386_elf32_vec
6662 #define TARGET_LITTLE_NAME "elf32-i386"
6663 #define ELF_ARCH bfd_arch_i386
6664 #define ELF_TARGET_ID I386_ELF_DATA
6665 #define ELF_MACHINE_CODE EM_386
6666 #define ELF_MAXPAGESIZE 0x1000
6668 #define elf_backend_can_gc_sections 1
6669 #define elf_backend_can_refcount 1
6670 #define elf_backend_want_got_plt 1
6671 #define elf_backend_plt_readonly 1
6672 #define elf_backend_want_plt_sym 0
6673 #define elf_backend_got_header_size 12
6674 #define elf_backend_plt_alignment 4
6675 #define elf_backend_dtrel_excludes_plt 1
6676 #define elf_backend_extern_protected_data 1
6677 #define elf_backend_caches_rawsize 1
6678 #define elf_backend_want_dynrelro 1
6680 /* Support RELA for objdump of prelink objects. */
6681 #define elf_info_to_howto elf_i386_info_to_howto_rel
6682 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6684 #define bfd_elf32_mkobject elf_i386_mkobject
6686 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6687 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6688 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6689 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6690 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6692 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6693 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6694 #define elf_backend_check_relocs elf_i386_check_relocs
6695 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6696 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
6697 #define elf_backend_fake_sections elf_i386_fake_sections
6698 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6699 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6700 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6701 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6702 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6703 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6704 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6705 #define elf_backend_relocate_section elf_i386_relocate_section
6706 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6707 #define elf_backend_always_size_sections elf_i386_always_size_sections
6708 #define elf_backend_omit_section_dynsym \
6709 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6710 #define elf_backend_hash_symbol elf_i386_hash_symbol
6711 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6712 #define elf_backend_parse_gnu_properties elf_i386_parse_gnu_properties
6713 #define elf_backend_merge_gnu_properties elf_i386_merge_gnu_properties
6714 #define elf_backend_setup_gnu_properties elf_i386_link_setup_gnu_properties
6716 #include "elf32-target.h"
6718 /* FreeBSD support. */
6720 #undef TARGET_LITTLE_SYM
6721 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6722 #undef TARGET_LITTLE_NAME
6723 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6725 #define ELF_OSABI ELFOSABI_FREEBSD
6727 /* The kernel recognizes executables as valid only if they carry a
6728 "FreeBSD" label in the ELF header. So we put this label on all
6729 executables and (for simplicity) also all other object files. */
6732 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
6734 _bfd_elf_post_process_headers (abfd
, info
);
6736 #ifdef OLD_FREEBSD_ABI_LABEL
6738 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6739 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6740 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
6745 #undef elf_backend_post_process_headers
6746 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6748 #define elf32_bed elf32_i386_fbsd_bed
6750 #undef elf_backend_add_symbol_hook
6752 #include "elf32-target.h"
6756 #undef TARGET_LITTLE_SYM
6757 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6758 #undef TARGET_LITTLE_NAME
6759 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6761 #undef elf_backend_post_process_headers
6763 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6764 objects won't be recognized. */
6768 #define elf32_bed elf32_i386_sol2_bed
6770 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6772 #undef elf_backend_static_tls_alignment
6773 #define elf_backend_static_tls_alignment 8
6775 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6777 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6779 #undef elf_backend_want_plt_sym
6780 #define elf_backend_want_plt_sym 1
6782 #undef elf_backend_strtab_flags
6783 #define elf_backend_strtab_flags SHF_STRINGS
6785 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6786 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6787 FALSE otherwise. ISECTION is the best guess matching section from the
6788 input bfd IBFD, but it might be NULL. */
6791 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6792 bfd
*obfd ATTRIBUTE_UNUSED
,
6793 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6794 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6796 /* PR 19938: FIXME: Need to add code for setting the sh_info
6797 and sh_link fields of Solaris specific section types. */
6800 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6801 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6803 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6805 The following values should be set:
6808 -----------------------------------------------------------------------------
6809 SHT_SUNW_ancillary The section header index of 0
6810 [0x6fffffee] the associated string table.
6812 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6813 [0x6ffffff0] the associated symbol table. section header index of
6815 SHT_SUNW_capchain table,
6818 SHT_SUNW_symsort The section header index of 0
6819 [0x6ffffff1] the associated symbol table.
6821 SHT_SUNW_tlssort The section header index of 0
6822 [0x6ffffff2] the associated symbol table.
6824 SHT_SUNW_LDYNSYM The section header index of One greater than the
6825 [0x6ffffff3] the associated string table. symbol table index of the
6826 This index is the same string last local symbol,
6827 table used by the SHT_DYNSYM STB_LOCAL. Since
6828 section. SHT_SUNW_LDYNSYM only
6829 contains local symbols,
6830 sh_info is equivalent to
6831 the number of symbols in
6834 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6835 [0x6ffffff5] the section header index of to named strings, the
6836 the associated section header index of
6837 SHT_SUNW_capinfo table, the associated string
6838 otherwise 0. table, otherwise 0.
6840 SHT_SUNW_move The section header index of 0
6841 [0x6ffffffa] the associated symbol table.
6846 SHT_SUNW_syminfo The section header index of The section header index
6847 [0x6ffffffc] the associated symbol table. of the associated
6850 SHT_SUNW_verdef The section header index of The number of version
6851 [0x6ffffffd] the associated string table. definitions within the
6854 SHT_SUNW_verneed The section header index of The number of version
6855 [0x6ffffffe] the associated string table. dependencies within the
6858 SHT_SUNW_versym The section header index of 0
6859 [0x6fffffff] the associated symbol table. */
6862 #undef elf_backend_copy_special_section_fields
6863 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6865 #include "elf32-target.h"
6867 /* Intel MCU support. */
6870 elf32_iamcu_elf_object_p (bfd
*abfd
)
6872 /* Set the right machine number for an IAMCU elf32 file. */
6873 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6877 #undef TARGET_LITTLE_SYM
6878 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6879 #undef TARGET_LITTLE_NAME
6880 #define TARGET_LITTLE_NAME "elf32-iamcu"
6882 #define ELF_ARCH bfd_arch_iamcu
6884 #undef ELF_MACHINE_CODE
6885 #define ELF_MACHINE_CODE EM_IAMCU
6890 #define elf32_bed elf32_iamcu_bed
6892 #undef elf_backend_object_p
6893 #define elf_backend_object_p elf32_iamcu_elf_object_p
6895 #undef elf_backend_static_tls_alignment
6897 #undef elf_backend_want_plt_sym
6898 #define elf_backend_want_plt_sym 0
6900 #undef elf_backend_strtab_flags
6901 #undef elf_backend_copy_special_section_fields
6903 #include "elf32-target.h"
6905 /* Restore defaults. */
6907 #define ELF_ARCH bfd_arch_i386
6908 #undef ELF_MACHINE_CODE
6909 #define ELF_MACHINE_CODE EM_386
6911 /* Native Client support. */
6913 #undef TARGET_LITTLE_SYM
6914 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6915 #undef TARGET_LITTLE_NAME
6916 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6918 #define elf32_bed elf32_i386_nacl_bed
6920 #undef ELF_MAXPAGESIZE
6921 #define ELF_MAXPAGESIZE 0x10000
6923 /* Restore defaults. */
6925 #undef elf_backend_want_plt_sym
6926 #define elf_backend_want_plt_sym 0
6927 #undef elf_backend_post_process_headers
6928 #undef elf_backend_static_tls_alignment
6930 /* NaCl uses substantially different PLT entries for the same effects. */
6932 #undef elf_backend_plt_alignment
6933 #define elf_backend_plt_alignment 5
6934 #define NACL_PLT_ENTRY_SIZE 64
6935 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6937 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6939 0xff, 0x35, /* pushl contents of address */
6940 0, 0, 0, 0, /* replaced with address of .got + 4. */
6941 0x8b, 0x0d, /* movl contents of address, %ecx */
6942 0, 0, 0, 0, /* replaced with address of .got + 8. */
6943 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6944 0xff, 0xe1 /* jmp *%ecx */
6947 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6949 0x8b, 0x0d, /* movl contents of address, %ecx */
6950 0, 0, 0, 0, /* replaced with GOT slot address. */
6951 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6952 0xff, 0xe1, /* jmp *%ecx */
6954 /* Pad to the next 32-byte boundary with nop instructions. */
6956 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6957 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6959 /* Lazy GOT entries point here (32-byte aligned). */
6960 0x68, /* pushl immediate */
6961 0, 0, 0, 0, /* replaced with reloc offset. */
6962 0xe9, /* jmp relative */
6963 0, 0, 0, 0, /* replaced with offset to .plt. */
6965 /* Pad to the next 32-byte boundary with nop instructions. */
6966 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6967 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6971 static const bfd_byte
6972 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6974 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6975 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6976 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6977 0xff, 0xe1, /* jmp *%ecx */
6979 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6980 so pad to that size with nop instructions. */
6981 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6984 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6986 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6987 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6988 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6989 0xff, 0xe1, /* jmp *%ecx */
6991 /* Pad to the next 32-byte boundary with nop instructions. */
6993 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6994 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6996 /* Lazy GOT entries point here (32-byte aligned). */
6997 0x68, /* pushl immediate */
6998 0, 0, 0, 0, /* replaced with offset into relocation table. */
6999 0xe9, /* jmp relative */
7000 0, 0, 0, 0, /* replaced with offset to start of .plt. */
7002 /* Pad to the next 32-byte boundary with nop instructions. */
7003 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
7004 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
7008 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
7010 #if (PLT_CIE_LENGTH != 20 \
7011 || PLT_FDE_LENGTH != 36 \
7012 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
7013 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
7014 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
7016 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
7017 0, 0, 0, 0, /* CIE ID */
7018 1, /* CIE version */
7019 'z', 'R', 0, /* Augmentation string */
7020 1, /* Code alignment factor */
7021 0x7c, /* Data alignment factor: -4 */
7022 8, /* Return address column */
7023 1, /* Augmentation size */
7024 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
7025 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
7026 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
7027 DW_CFA_nop
, DW_CFA_nop
,
7029 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
7030 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
7031 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
7032 0, 0, 0, 0, /* .plt size goes here */
7033 0, /* Augmentation size */
7034 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
7035 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
7036 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
7037 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
7038 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
7039 13, /* Block length */
7040 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
7041 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
7042 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
7043 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
7044 DW_CFA_nop
, DW_CFA_nop
7047 static const struct elf_i386_lazy_plt_layout elf_i386_nacl_plt
=
7049 elf_i386_nacl_plt0_entry
, /* plt0_entry */
7050 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
7051 2, /* plt0_got1_offset */
7052 8, /* plt0_got2_offset */
7053 elf_i386_nacl_plt_entry
, /* plt_entry */
7054 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
7055 2, /* plt_got_offset */
7056 33, /* plt_reloc_offset */
7057 38, /* plt_plt_offset */
7058 32, /* plt_lazy_offset */
7059 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
7060 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
7061 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
7062 sizeof (elf_i386_nacl_eh_frame_plt
) /* eh_frame_plt_size */
7065 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
7067 0x90, /* plt0_pad_byte: nop insn */
7072 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
7074 /* Set the right machine number for a NaCl i386 ELF32 file. */
7075 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
7079 #undef elf_backend_arch_data
7080 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
7082 #undef elf_backend_object_p
7083 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
7084 #undef elf_backend_modify_segment_map
7085 #define elf_backend_modify_segment_map nacl_modify_segment_map
7086 #undef elf_backend_modify_program_headers
7087 #define elf_backend_modify_program_headers nacl_modify_program_headers
7088 #undef elf_backend_final_write_processing
7089 #define elf_backend_final_write_processing nacl_final_write_processing
7091 #include "elf32-target.h"
7093 /* Restore defaults. */
7094 #undef elf_backend_object_p
7095 #undef elf_backend_modify_segment_map
7096 #undef elf_backend_modify_program_headers
7097 #undef elf_backend_final_write_processing
7099 /* VxWorks support. */
7101 #undef TARGET_LITTLE_SYM
7102 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
7103 #undef TARGET_LITTLE_NAME
7104 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
7106 #undef ELF_MAXPAGESIZE
7107 #define ELF_MAXPAGESIZE 0x1000
7108 #undef elf_backend_plt_alignment
7109 #define elf_backend_plt_alignment 4
7111 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
7113 0x90, /* plt0_pad_byte */
7117 #undef elf_backend_arch_data
7118 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
7120 #undef elf_backend_relocs_compatible
7121 #undef elf_backend_add_symbol_hook
7122 #define elf_backend_add_symbol_hook \
7123 elf_vxworks_add_symbol_hook
7124 #undef elf_backend_link_output_symbol_hook
7125 #define elf_backend_link_output_symbol_hook \
7126 elf_vxworks_link_output_symbol_hook
7127 #undef elf_backend_emit_relocs
7128 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7129 #undef elf_backend_final_write_processing
7130 #define elf_backend_final_write_processing \
7131 elf_vxworks_final_write_processing
7132 #undef elf_backend_static_tls_alignment
7134 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
7136 #undef elf_backend_want_plt_sym
7137 #define elf_backend_want_plt_sym 1
7140 #define elf32_bed elf32_i386_vxworks_bed
7142 #include "elf32-target.h"