1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2016 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 procedure linkage table. */
546 #define PLT_ENTRY_SIZE 16
548 /* The first entry in an absolute procedure linkage table looks like
549 this. See the SVR4 ABI i386 supplement to see how this works.
550 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
552 static const bfd_byte elf_i386_plt0_entry
[12] =
554 0xff, 0x35, /* pushl contents of address */
555 0, 0, 0, 0, /* replaced with address of .got + 4. */
556 0xff, 0x25, /* jmp indirect */
557 0, 0, 0, 0 /* replaced with address of .got + 8. */
560 /* Subsequent entries in an absolute procedure linkage table look like
563 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
565 0xff, 0x25, /* jmp indirect */
566 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
567 0x68, /* pushl immediate */
568 0, 0, 0, 0, /* replaced with offset into relocation table. */
569 0xe9, /* jmp relative */
570 0, 0, 0, 0 /* replaced with offset to start of .plt. */
573 /* The first entry in a PIC procedure linkage table look like this.
574 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
576 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
578 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
579 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
582 /* Subsequent entries in a PIC procedure linkage table look like this. */
584 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
586 0xff, 0xa3, /* jmp *offset(%ebx) */
587 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
588 0x68, /* pushl immediate */
589 0, 0, 0, 0, /* replaced with offset into relocation table. */
590 0xe9, /* jmp relative */
591 0, 0, 0, 0 /* replaced with offset to start of .plt. */
594 /* Entries in the GOT procedure linkage table look like this. */
596 static const bfd_byte elf_i386_got_plt_entry
[8] =
598 0xff, 0x25, /* jmp indirect */
599 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries in the PIC GOT procedure linkage table look like this. */
605 static const bfd_byte elf_i386_pic_got_plt_entry
[8] =
607 0xff, 0xa3, /* jmp *offset(%ebx) */
608 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* .eh_frame covering the .plt section. */
614 static const bfd_byte elf_i386_eh_frame_plt
[] =
616 #define PLT_CIE_LENGTH 20
617 #define PLT_FDE_LENGTH 36
618 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
619 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
620 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
621 0, 0, 0, 0, /* CIE ID */
623 'z', 'R', 0, /* Augmentation string */
624 1, /* Code alignment factor */
625 0x7c, /* Data alignment factor */
626 8, /* Return address column */
627 1, /* Augmentation size */
628 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
629 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
630 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
631 DW_CFA_nop
, DW_CFA_nop
,
633 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
634 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
635 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
636 0, 0, 0, 0, /* .plt size goes here */
637 0, /* Augmentation size */
638 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
639 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
640 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
641 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
642 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
643 11, /* Block length */
644 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
645 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
646 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
647 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
648 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
651 struct elf_i386_plt_layout
653 /* The first entry in an absolute procedure linkage table looks like this. */
654 const bfd_byte
*plt0_entry
;
655 unsigned int plt0_entry_size
;
657 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
658 unsigned int plt0_got1_offset
;
659 unsigned int plt0_got2_offset
;
661 /* Later entries in an absolute procedure linkage table look like this. */
662 const bfd_byte
*plt_entry
;
663 unsigned int plt_entry_size
;
665 /* Offsets into plt_entry that are to be replaced with... */
666 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
667 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
668 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
670 /* Offset into plt_entry where the initial value of the GOT entry points. */
671 unsigned int plt_lazy_offset
;
673 /* The first entry in a PIC procedure linkage table looks like this. */
674 const bfd_byte
*pic_plt0_entry
;
676 /* Subsequent entries in a PIC procedure linkage table look like this. */
677 const bfd_byte
*pic_plt_entry
;
679 /* .eh_frame covering the .plt section. */
680 const bfd_byte
*eh_frame_plt
;
681 unsigned int eh_frame_plt_size
;
684 #define GET_PLT_ENTRY_SIZE(abfd) \
685 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
687 /* These are the standard parameters. */
688 static const struct elf_i386_plt_layout elf_i386_plt
=
690 elf_i386_plt0_entry
, /* plt0_entry */
691 sizeof (elf_i386_plt0_entry
), /* plt0_entry_size */
692 2, /* plt0_got1_offset */
693 8, /* plt0_got2_offset */
694 elf_i386_plt_entry
, /* plt_entry */
695 PLT_ENTRY_SIZE
, /* plt_entry_size */
696 2, /* plt_got_offset */
697 7, /* plt_reloc_offset */
698 12, /* plt_plt_offset */
699 6, /* plt_lazy_offset */
700 elf_i386_pic_plt0_entry
, /* pic_plt0_entry */
701 elf_i386_pic_plt_entry
, /* pic_plt_entry */
702 elf_i386_eh_frame_plt
, /* eh_frame_plt */
703 sizeof (elf_i386_eh_frame_plt
), /* eh_frame_plt_size */
707 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
708 for the PLTResolve stub and then for each PLT entry. */
709 #define PLTRESOLVE_RELOCS_SHLIB 0
710 #define PLTRESOLVE_RELOCS 2
711 #define PLT_NON_JUMP_SLOT_RELOCS 2
713 /* Architecture-specific backend data for i386. */
715 struct elf_i386_backend_data
717 /* Parameters describing PLT generation. */
718 const struct elf_i386_plt_layout
*plt
;
720 /* Value used to fill the unused bytes of the first PLT entry. */
721 bfd_byte plt0_pad_byte
;
723 /* True if the target system is VxWorks. */
727 #define get_elf_i386_backend_data(abfd) \
728 ((const struct elf_i386_backend_data *) \
729 get_elf_backend_data (abfd)->arch_data)
731 /* These are the standard parameters. */
732 static const struct elf_i386_backend_data elf_i386_arch_bed
=
734 &elf_i386_plt
, /* plt */
735 0, /* plt0_pad_byte */
739 #define elf_backend_arch_data &elf_i386_arch_bed
741 /* Is a undefined weak symbol which is resolved to 0. Reference to an
742 undefined weak symbol is resolved to 0 when building executable if
744 1. Has non-GOT/non-PLT relocations in text section. Or
745 2. Has no GOT/PLT relocation.
747 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
748 ((EH)->elf.root.type == bfd_link_hash_undefweak \
749 && bfd_link_executable (INFO) \
750 && (elf_i386_hash_table (INFO)->interp == NULL \
752 || (EH)->has_non_got_reloc \
753 || !(INFO)->dynamic_undefined_weak))
755 /* i386 ELF linker hash entry. */
757 struct elf_i386_link_hash_entry
759 struct elf_link_hash_entry elf
;
761 /* Track dynamic relocs copied for this symbol. */
762 struct elf_dyn_relocs
*dyn_relocs
;
764 #define GOT_UNKNOWN 0
768 #define GOT_TLS_IE_POS 5
769 #define GOT_TLS_IE_NEG 6
770 #define GOT_TLS_IE_BOTH 7
771 #define GOT_TLS_GDESC 8
772 #define GOT_TLS_GD_BOTH_P(type) \
773 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
774 #define GOT_TLS_GD_P(type) \
775 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
776 #define GOT_TLS_GDESC_P(type) \
777 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
778 #define GOT_TLS_GD_ANY_P(type) \
779 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
780 unsigned char tls_type
;
782 /* Symbol is referenced by R_386_GOTOFF relocation. */
783 unsigned int gotoff_ref
: 1;
785 /* Symbol has GOT or PLT relocations. */
786 unsigned int has_got_reloc
: 1;
788 /* Symbol has non-GOT/non-PLT relocations in text sections. */
789 unsigned int has_non_got_reloc
: 1;
791 /* 0: symbol isn't ___tls_get_addr.
792 1: symbol is ___tls_get_addr.
793 2: symbol is unknown. */
794 unsigned int tls_get_addr
: 2;
796 /* Reference count of C/C++ function pointer relocations in read-write
797 section which can be resolved at run-time. */
798 bfd_signed_vma func_pointer_refcount
;
800 /* Information about the GOT PLT entry. Filled when there are both
801 GOT and PLT relocations against the same function. */
802 union gotplt_union plt_got
;
804 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
805 starting at the end of the jump table. */
809 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
811 struct elf_i386_obj_tdata
813 struct elf_obj_tdata root
;
815 /* tls_type for each local got entry. */
816 char *local_got_tls_type
;
818 /* GOTPLT entries for TLS descriptors. */
819 bfd_vma
*local_tlsdesc_gotent
;
822 #define elf_i386_tdata(abfd) \
823 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
825 #define elf_i386_local_got_tls_type(abfd) \
826 (elf_i386_tdata (abfd)->local_got_tls_type)
828 #define elf_i386_local_tlsdesc_gotent(abfd) \
829 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
831 #define is_i386_elf(bfd) \
832 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
833 && elf_tdata (bfd) != NULL \
834 && elf_object_id (bfd) == I386_ELF_DATA)
837 elf_i386_mkobject (bfd
*abfd
)
839 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
843 /* i386 ELF linker hash table. */
845 struct elf_i386_link_hash_table
847 struct elf_link_hash_table elf
;
849 /* Short-cuts to get to dynamic linker sections. */
851 asection
*plt_eh_frame
;
856 bfd_signed_vma refcount
;
860 /* The amount of space used by the reserved portion of the sgotplt
861 section, plus whatever space is used by the jump slots. */
862 bfd_vma sgotplt_jump_table_size
;
864 /* Small local sym cache. */
865 struct sym_cache sym_cache
;
867 /* _TLS_MODULE_BASE_ symbol. */
868 struct bfd_link_hash_entry
*tls_module_base
;
870 /* Used by local STT_GNU_IFUNC symbols. */
871 htab_t loc_hash_table
;
872 void * loc_hash_memory
;
874 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
877 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
878 bfd_vma next_tls_desc_index
;
880 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
881 bfd_vma next_jump_slot_index
;
883 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
884 bfd_vma next_irelative_index
;
886 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
887 to read-only sections. */
888 bfd_boolean readonly_dynrelocs_against_ifunc
;
891 /* Get the i386 ELF linker hash table from a link_info structure. */
893 #define elf_i386_hash_table(p) \
894 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
895 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
897 #define elf_i386_compute_jump_table_size(htab) \
898 ((htab)->elf.srelplt->reloc_count * 4)
900 /* Create an entry in an i386 ELF linker hash table. */
902 static struct bfd_hash_entry
*
903 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
904 struct bfd_hash_table
*table
,
907 /* Allocate the structure if it has not already been allocated by a
911 entry
= (struct bfd_hash_entry
*)
912 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
917 /* Call the allocation method of the superclass. */
918 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
921 struct elf_i386_link_hash_entry
*eh
;
923 eh
= (struct elf_i386_link_hash_entry
*) entry
;
924 eh
->dyn_relocs
= NULL
;
925 eh
->tls_type
= GOT_UNKNOWN
;
927 eh
->has_got_reloc
= 0;
928 eh
->has_non_got_reloc
= 0;
929 eh
->tls_get_addr
= 2;
930 eh
->func_pointer_refcount
= 0;
931 eh
->plt_got
.offset
= (bfd_vma
) -1;
932 eh
->tlsdesc_got
= (bfd_vma
) -1;
938 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
939 for local symbol so that we can handle local STT_GNU_IFUNC symbols
940 as global symbol. We reuse indx and dynstr_index for local symbol
941 hash since they aren't used by global symbols in this backend. */
944 elf_i386_local_htab_hash (const void *ptr
)
946 struct elf_link_hash_entry
*h
947 = (struct elf_link_hash_entry
*) ptr
;
948 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
951 /* Compare local hash entries. */
954 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
956 struct elf_link_hash_entry
*h1
957 = (struct elf_link_hash_entry
*) ptr1
;
958 struct elf_link_hash_entry
*h2
959 = (struct elf_link_hash_entry
*) ptr2
;
961 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
964 /* Find and/or create a hash entry for local symbol. */
966 static struct elf_link_hash_entry
*
967 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
968 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
971 struct elf_i386_link_hash_entry e
, *ret
;
972 asection
*sec
= abfd
->sections
;
973 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
974 ELF32_R_SYM (rel
->r_info
));
977 e
.elf
.indx
= sec
->id
;
978 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
979 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
980 create
? INSERT
: NO_INSERT
);
987 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
991 ret
= (struct elf_i386_link_hash_entry
*)
992 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
993 sizeof (struct elf_i386_link_hash_entry
));
996 memset (ret
, 0, sizeof (*ret
));
997 ret
->elf
.indx
= sec
->id
;
998 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
999 ret
->elf
.dynindx
= -1;
1000 ret
->func_pointer_refcount
= 0;
1001 ret
->plt_got
.offset
= (bfd_vma
) -1;
1007 /* Destroy an i386 ELF linker hash table. */
1010 elf_i386_link_hash_table_free (bfd
*obfd
)
1012 struct elf_i386_link_hash_table
*htab
1013 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1015 if (htab
->loc_hash_table
)
1016 htab_delete (htab
->loc_hash_table
);
1017 if (htab
->loc_hash_memory
)
1018 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1019 _bfd_elf_link_hash_table_free (obfd
);
1022 /* Create an i386 ELF linker hash table. */
1024 static struct bfd_link_hash_table
*
1025 elf_i386_link_hash_table_create (bfd
*abfd
)
1027 struct elf_i386_link_hash_table
*ret
;
1028 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1030 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1034 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1035 elf_i386_link_hash_newfunc
,
1036 sizeof (struct elf_i386_link_hash_entry
),
1043 ret
->loc_hash_table
= htab_try_create (1024,
1044 elf_i386_local_htab_hash
,
1045 elf_i386_local_htab_eq
,
1047 ret
->loc_hash_memory
= objalloc_create ();
1048 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1050 elf_i386_link_hash_table_free (abfd
);
1053 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1055 return &ret
->elf
.root
;
1058 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1059 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1063 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1065 struct elf_i386_link_hash_table
*htab
;
1067 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1070 htab
= elf_i386_hash_table (info
);
1074 /* Set the contents of the .interp section to the interpreter. */
1075 if (bfd_link_executable (info
) && !info
->nointerp
)
1077 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1080 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1081 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1085 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1086 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1090 if (!info
->no_ld_generated_unwind_info
1091 && htab
->plt_eh_frame
== NULL
1092 && htab
->elf
.splt
!= NULL
)
1094 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1095 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1096 | SEC_LINKER_CREATED
);
1098 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1099 if (htab
->plt_eh_frame
== NULL
1100 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1107 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1110 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1111 struct elf_link_hash_entry
*dir
,
1112 struct elf_link_hash_entry
*ind
)
1114 struct elf_i386_link_hash_entry
*edir
, *eind
;
1116 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1117 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1119 if (eind
->dyn_relocs
!= NULL
)
1121 if (edir
->dyn_relocs
!= NULL
)
1123 struct elf_dyn_relocs
**pp
;
1124 struct elf_dyn_relocs
*p
;
1126 /* Add reloc counts against the indirect sym to the direct sym
1127 list. Merge any entries against the same section. */
1128 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1130 struct elf_dyn_relocs
*q
;
1132 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1133 if (q
->sec
== p
->sec
)
1135 q
->pc_count
+= p
->pc_count
;
1136 q
->count
+= p
->count
;
1143 *pp
= edir
->dyn_relocs
;
1146 edir
->dyn_relocs
= eind
->dyn_relocs
;
1147 eind
->dyn_relocs
= NULL
;
1150 if (ind
->root
.type
== bfd_link_hash_indirect
1151 && dir
->got
.refcount
<= 0)
1153 edir
->tls_type
= eind
->tls_type
;
1154 eind
->tls_type
= GOT_UNKNOWN
;
1157 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1158 generate a R_386_COPY reloc. */
1159 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1161 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1162 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1164 if (ELIMINATE_COPY_RELOCS
1165 && ind
->root
.type
!= bfd_link_hash_indirect
1166 && dir
->dynamic_adjusted
)
1168 /* If called to transfer flags for a weakdef during processing
1169 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1170 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1171 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1172 dir
->ref_regular
|= ind
->ref_regular
;
1173 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1174 dir
->needs_plt
|= ind
->needs_plt
;
1175 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1179 if (eind
->func_pointer_refcount
> 0)
1181 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1182 eind
->func_pointer_refcount
= 0;
1185 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1189 /* Return TRUE if the TLS access code sequence support transition
1193 elf_i386_check_tls_transition (asection
*sec
,
1195 Elf_Internal_Shdr
*symtab_hdr
,
1196 struct elf_link_hash_entry
**sym_hashes
,
1197 unsigned int r_type
,
1198 const Elf_Internal_Rela
*rel
,
1199 const Elf_Internal_Rela
*relend
)
1201 unsigned int val
, type
, reg
;
1202 unsigned long r_symndx
;
1203 struct elf_link_hash_entry
*h
;
1206 bfd_boolean indirect_call
, tls_get_addr
;
1208 offset
= rel
->r_offset
;
1213 if (offset
< 2 || (rel
+ 1) >= relend
)
1216 indirect_call
= FALSE
;
1217 call
= contents
+ offset
+ 4;
1220 if (r_type
== R_386_TLS_GD
)
1222 /* Check transition from GD access model. Only
1223 leal foo@tlsgd(,%ebx,1), %eax
1224 call ___tls_get_addr@PLT
1226 leal foo@tlsgd(%ebx) %eax
1227 call ___tls_get_addr@PLT
1230 leal foo@tlsgd(%reg), %eax
1231 call *___tls_get_addr@GOT(%reg)
1232 which may be converted to
1233 addr32 call ___tls_get_addr
1234 can transit to different access model. */
1235 if ((offset
+ 10) > sec
->size
1236 || (type
!= 0x8d && type
!= 0x04))
1241 /* leal foo@tlsgd(,%ebx,1), %eax
1242 call ___tls_get_addr@PLT */
1246 if (*(call
- 7) != 0x8d
1254 leal foo@tlsgd(%ebx), %eax
1255 call ___tls_get_addr@PLT
1258 leal foo@tlsgd(%reg), %eax
1259 call *___tls_get_addr@GOT(%reg)
1260 which may be converted to
1261 addr32 call ___tls_get_addr
1263 %eax can't be used as the GOT base register since it
1264 is used to pass parameter to ___tls_get_addr. */
1266 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1269 indirect_call
= call
[0] == 0xff;
1270 if (!(reg
== 3 && call
[0] == 0xe8 && call
[5] == 0x90)
1271 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1273 && (call
[1] & 0xf8) == 0x90
1274 && (call
[1] & 0x7) == reg
))
1280 /* Check transition from LD access model. Only
1281 leal foo@tlsldm(%ebx), %eax
1282 call ___tls_get_addr@PLT
1284 leal foo@tlsldm(%reg), %eax
1285 call *___tls_get_addr@GOT(%reg)
1286 which may be converted to
1287 addr32 call ___tls_get_addr
1288 can transit to different access model. */
1289 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1292 /* %eax can't be used as the GOT base register since it is
1293 used to pass parameter to ___tls_get_addr. */
1295 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1298 indirect_call
= call
[0] == 0xff;
1299 if (!(reg
== 3 && call
[0] == 0xe8)
1300 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1302 && (call
[1] & 0xf8) == 0x90
1303 && (call
[1] & 0x7) == reg
))
1307 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1308 if (r_symndx
< symtab_hdr
->sh_info
)
1311 tls_get_addr
= FALSE
;
1312 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1313 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1315 struct elf_i386_link_hash_entry
*eh
1316 = (struct elf_i386_link_hash_entry
*) h
;
1317 tls_get_addr
= eh
->tls_get_addr
== 1;
1318 if (eh
->tls_get_addr
> 1)
1320 /* Use strncmp to check ___tls_get_addr since
1321 ___tls_get_addr may be versioned. */
1322 if (strncmp (h
->root
.root
.string
, "___tls_get_addr", 15)
1325 eh
->tls_get_addr
= 1;
1326 tls_get_addr
= TRUE
;
1329 eh
->tls_get_addr
= 0;
1335 else if (indirect_call
)
1336 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_GOT32X
);
1338 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1339 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
1342 /* Check transition from IE access model:
1343 movl foo@indntpoff(%rip), %eax
1344 movl foo@indntpoff(%rip), %reg
1345 addl foo@indntpoff(%rip), %reg
1348 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1351 /* Check "movl foo@tpoff(%rip), %eax" first. */
1352 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1359 /* Check movl|addl foo@tpoff(%rip), %reg. */
1360 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1361 return ((type
== 0x8b || type
== 0x03)
1362 && (val
& 0xc7) == 0x05);
1364 case R_386_TLS_GOTIE
:
1365 case R_386_TLS_IE_32
:
1366 /* Check transition from {IE_32,GOTIE} access model:
1367 subl foo@{tpoff,gontoff}(%reg1), %reg2
1368 movl foo@{tpoff,gontoff}(%reg1), %reg2
1369 addl foo@{tpoff,gontoff}(%reg1), %reg2
1372 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1375 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1376 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1379 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1380 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1382 case R_386_TLS_GOTDESC
:
1383 /* Check transition from GDesc access model:
1384 leal x@tlsdesc(%ebx), %eax
1386 Make sure it's a leal adding ebx to a 32-bit offset
1387 into any register, although it's probably almost always
1390 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1393 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1396 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1397 return (val
& 0xc7) == 0x83;
1399 case R_386_TLS_DESC_CALL
:
1400 /* Check transition from GDesc access model:
1401 call *x@tlsdesc(%eax)
1403 if (offset
+ 2 <= sec
->size
)
1405 /* Make sure that it's a call *x@tlsdesc(%eax). */
1406 call
= contents
+ offset
;
1407 return call
[0] == 0xff && call
[1] == 0x10;
1417 /* Return TRUE if the TLS access transition is OK or no transition
1418 will be performed. Update R_TYPE if there is a transition. */
1421 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1422 asection
*sec
, bfd_byte
*contents
,
1423 Elf_Internal_Shdr
*symtab_hdr
,
1424 struct elf_link_hash_entry
**sym_hashes
,
1425 unsigned int *r_type
, int tls_type
,
1426 const Elf_Internal_Rela
*rel
,
1427 const Elf_Internal_Rela
*relend
,
1428 struct elf_link_hash_entry
*h
,
1429 unsigned long r_symndx
,
1430 bfd_boolean from_relocate_section
)
1432 unsigned int from_type
= *r_type
;
1433 unsigned int to_type
= from_type
;
1434 bfd_boolean check
= TRUE
;
1436 /* Skip TLS transition for functions. */
1438 && (h
->type
== STT_FUNC
1439 || h
->type
== STT_GNU_IFUNC
))
1445 case R_386_TLS_GOTDESC
:
1446 case R_386_TLS_DESC_CALL
:
1447 case R_386_TLS_IE_32
:
1449 case R_386_TLS_GOTIE
:
1450 if (bfd_link_executable (info
))
1453 to_type
= R_386_TLS_LE_32
;
1454 else if (from_type
!= R_386_TLS_IE
1455 && from_type
!= R_386_TLS_GOTIE
)
1456 to_type
= R_386_TLS_IE_32
;
1459 /* When we are called from elf_i386_relocate_section, there may
1460 be additional transitions based on TLS_TYPE. */
1461 if (from_relocate_section
)
1463 unsigned int new_to_type
= to_type
;
1465 if (bfd_link_executable (info
)
1468 && (tls_type
& GOT_TLS_IE
))
1469 new_to_type
= R_386_TLS_LE_32
;
1471 if (to_type
== R_386_TLS_GD
1472 || to_type
== R_386_TLS_GOTDESC
1473 || to_type
== R_386_TLS_DESC_CALL
)
1475 if (tls_type
== GOT_TLS_IE_POS
)
1476 new_to_type
= R_386_TLS_GOTIE
;
1477 else if (tls_type
& GOT_TLS_IE
)
1478 new_to_type
= R_386_TLS_IE_32
;
1481 /* We checked the transition before when we were called from
1482 elf_i386_check_relocs. We only want to check the new
1483 transition which hasn't been checked before. */
1484 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1485 to_type
= new_to_type
;
1491 if (bfd_link_executable (info
))
1492 to_type
= R_386_TLS_LE_32
;
1499 /* Return TRUE if there is no transition. */
1500 if (from_type
== to_type
)
1503 /* Check if the transition can be performed. */
1505 && ! elf_i386_check_tls_transition (sec
, contents
,
1506 symtab_hdr
, sym_hashes
,
1507 from_type
, rel
, relend
))
1509 reloc_howto_type
*from
, *to
;
1512 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1513 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1516 name
= h
->root
.root
.string
;
1519 struct elf_i386_link_hash_table
*htab
;
1521 htab
= elf_i386_hash_table (info
);
1526 Elf_Internal_Sym
*isym
;
1528 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1530 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1535 /* xgettext:c-format */
1536 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1537 "in section `%A' failed"),
1538 abfd
, sec
, from
->name
, to
->name
, name
,
1539 (unsigned long) rel
->r_offset
);
1540 bfd_set_error (bfd_error_bad_value
);
1548 /* With the local symbol, foo, we convert
1549 mov foo@GOT[(%reg1)], %reg2
1551 lea foo[@GOTOFF(%reg1)], %reg2
1553 call/jmp *foo@GOT[(%reg)]
1555 nop call foo/jmp foo nop
1556 When PIC is false, convert
1557 test %reg1, foo@GOT[(%reg2)]
1561 binop foo@GOT[(%reg1)], %reg2
1564 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1569 elf_i386_convert_load_reloc (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
1571 Elf_Internal_Rela
*irel
,
1572 struct elf_link_hash_entry
*h
,
1573 bfd_boolean
*converted
,
1574 struct bfd_link_info
*link_info
)
1576 struct elf_i386_link_hash_table
*htab
;
1577 unsigned int opcode
;
1579 bfd_boolean baseless
;
1580 Elf_Internal_Sym
*isym
;
1581 unsigned int addend
;
1585 bfd_boolean to_reloc_32
;
1586 unsigned int r_type
;
1587 unsigned int r_symndx
;
1588 bfd_vma roff
= irel
->r_offset
;
1593 /* Addend for R_386_GOT32X relocations must be 0. */
1594 addend
= bfd_get_32 (abfd
, contents
+ roff
);
1598 htab
= elf_i386_hash_table (link_info
);
1599 is_pic
= bfd_link_pic (link_info
);
1601 r_type
= ELF32_R_TYPE (irel
->r_info
);
1602 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1604 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1605 baseless
= (modrm
& 0xc7) == 0x5;
1607 if (baseless
&& is_pic
)
1609 /* For PIC, disallow R_386_GOT32X without a base register
1610 since we don't know what the GOT base is. */
1615 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
1617 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1620 name
= h
->root
.root
.string
;
1623 /* xgettext:c-format */
1624 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1629 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1631 /* Convert to R_386_32 if PIC is false or there is no base
1633 to_reloc_32
= !is_pic
|| baseless
;
1635 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1639 if (opcode
== 0x0ff)
1640 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1641 goto convert_branch
;
1643 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1644 "test %reg1, foo@GOT(%reg2)" and
1645 "binop foo@GOT[(%reg1)], %reg2". */
1649 /* Undefined weak symbol is only bound locally in executable
1650 and its reference is resolved as 0. */
1651 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
1652 elf_i386_hash_entry (h
)))
1656 /* No direct branch to 0 for PIC. */
1660 goto convert_branch
;
1664 /* We can convert load of address 0 to R_386_32. */
1672 /* We have "call/jmp *foo@GOT[(%reg)]". */
1673 if ((h
->root
.type
== bfd_link_hash_defined
1674 || h
->root
.type
== bfd_link_hash_defweak
)
1675 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1677 /* The function is locally defined. */
1679 /* Convert R_386_GOT32X to R_386_PC32. */
1680 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
1682 struct elf_i386_link_hash_entry
*eh
1683 = (struct elf_i386_link_hash_entry
*) h
;
1685 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1688 /* To support TLS optimization, always use addr32 prefix
1689 for "call *___tls_get_addr@GOT(%reg)". */
1690 if (eh
&& eh
->tls_get_addr
== 1)
1693 nop_offset
= irel
->r_offset
- 2;
1697 nop
= link_info
->call_nop_byte
;
1698 if (link_info
->call_nop_as_suffix
)
1700 nop_offset
= roff
+ 3;
1701 irel
->r_offset
-= 1;
1704 nop_offset
= roff
- 2;
1709 /* Convert to "jmp foo nop". */
1712 nop_offset
= roff
+ 3;
1713 irel
->r_offset
-= 1;
1716 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1717 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1718 /* When converting to PC-relative relocation, we
1719 need to adjust addend by -4. */
1720 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
1721 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
1728 /* We have "mov foo@GOT[(%re1g)], %reg2",
1729 "test %reg1, foo@GOT(%reg2)" and
1730 "binop foo@GOT[(%reg1)], %reg2".
1732 Avoid optimizing _DYNAMIC since ld.so may use its
1733 link-time address. */
1734 if (h
== htab
->elf
.hdynamic
)
1737 /* def_regular is set by an assignment in a linker script in
1738 bfd_elf_record_link_assignment. */
1740 || h
->root
.type
== bfd_link_hash_defined
1741 || h
->root
.type
== bfd_link_hash_defweak
)
1742 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1749 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1750 "mov $foo, %reg2" with R_386_32. */
1752 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1753 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1758 /* Convert "mov foo@GOT(%reg1), %reg2" to
1759 "lea foo@GOTOFF(%reg1), %reg2". */
1760 r_type
= R_386_GOTOFF
;
1766 /* Only R_386_32 is supported. */
1772 /* Convert "test %reg1, foo@GOT(%reg2)" to
1773 "test $foo, %reg1". */
1774 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1779 /* Convert "binop foo@GOT(%reg1), %reg2" to
1780 "binop $foo, %reg2". */
1782 | (modrm
& 0x38) >> 3
1786 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1790 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1791 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1800 /* Rename some of the generic section flags to better document how they
1802 #define need_convert_load sec_flg0
1803 #define check_relocs_failed sec_flg1
1805 /* Look through the relocs for a section during the first phase, and
1806 calculate needed space in the global offset table, procedure linkage
1807 table, and dynamic reloc sections. */
1810 elf_i386_check_relocs (bfd
*abfd
,
1811 struct bfd_link_info
*info
,
1813 const Elf_Internal_Rela
*relocs
)
1815 struct elf_i386_link_hash_table
*htab
;
1816 Elf_Internal_Shdr
*symtab_hdr
;
1817 struct elf_link_hash_entry
**sym_hashes
;
1818 const Elf_Internal_Rela
*rel
;
1819 const Elf_Internal_Rela
*rel_end
;
1822 bfd_boolean use_plt_got
;
1824 if (bfd_link_relocatable (info
))
1827 /* Don't do anything special with non-loaded, non-alloced sections.
1828 In particular, any relocs in such sections should not affect GOT
1829 and PLT reference counting (ie. we don't allow them to create GOT
1830 or PLT entries), there's no possibility or desire to optimize TLS
1831 relocs, and there's not much point in propagating relocs to shared
1832 libs that the dynamic linker won't relocate. */
1833 if ((sec
->flags
& SEC_ALLOC
) == 0)
1836 BFD_ASSERT (is_i386_elf (abfd
));
1838 htab
= elf_i386_hash_table (info
);
1841 sec
->check_relocs_failed
= 1;
1845 /* Get the section contents. */
1846 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1847 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1848 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1850 sec
->check_relocs_failed
= 1;
1854 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1855 && (get_elf_i386_backend_data (abfd
)
1856 == &elf_i386_arch_bed
));
1858 symtab_hdr
= &elf_symtab_hdr (abfd
);
1859 sym_hashes
= elf_sym_hashes (abfd
);
1863 rel_end
= relocs
+ sec
->reloc_count
;
1864 for (rel
= relocs
; rel
< rel_end
; rel
++)
1866 unsigned int r_type
;
1867 unsigned long r_symndx
;
1868 struct elf_link_hash_entry
*h
;
1869 struct elf_i386_link_hash_entry
*eh
;
1870 Elf_Internal_Sym
*isym
;
1872 bfd_boolean size_reloc
;
1874 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1875 r_type
= ELF32_R_TYPE (rel
->r_info
);
1877 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1879 /* xgettext:c-format */
1880 _bfd_error_handler (_("%B: bad symbol index: %d"),
1885 if (r_symndx
< symtab_hdr
->sh_info
)
1887 /* A local symbol. */
1888 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1893 /* Check relocation against local STT_GNU_IFUNC symbol. */
1894 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1896 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1900 /* Fake a STT_GNU_IFUNC symbol. */
1901 h
->type
= STT_GNU_IFUNC
;
1904 h
->forced_local
= 1;
1905 h
->root
.type
= bfd_link_hash_defined
;
1913 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1914 while (h
->root
.type
== bfd_link_hash_indirect
1915 || h
->root
.type
== bfd_link_hash_warning
)
1916 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1919 eh
= (struct elf_i386_link_hash_entry
*) h
;
1935 if (htab
->elf
.dynobj
== NULL
)
1936 htab
->elf
.dynobj
= abfd
;
1937 /* Create the ifunc sections for static executables. */
1938 if (h
->type
== STT_GNU_IFUNC
1939 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1945 /* It is referenced by a non-shared object. */
1947 h
->root
.non_ir_ref
= 1;
1949 if (h
->type
== STT_GNU_IFUNC
)
1950 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1951 |= elf_gnu_symbol_ifunc
;
1954 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1955 symtab_hdr
, sym_hashes
,
1956 &r_type
, GOT_UNKNOWN
,
1957 rel
, rel_end
, h
, r_symndx
, FALSE
))
1963 htab
->tls_ldm_got
.refcount
+= 1;
1967 /* This symbol requires a procedure linkage table entry. We
1968 actually build the entry in adjust_dynamic_symbol,
1969 because this might be a case of linking PIC code which is
1970 never referenced by a dynamic object, in which case we
1971 don't need to generate a procedure linkage table entry
1974 /* If this is a local symbol, we resolve it directly without
1975 creating a procedure linkage table entry. */
1979 eh
->has_got_reloc
= 1;
1981 h
->plt
.refcount
+= 1;
1988 case R_386_TLS_IE_32
:
1990 case R_386_TLS_GOTIE
:
1991 if (!bfd_link_executable (info
))
1992 info
->flags
|= DF_STATIC_TLS
;
1998 case R_386_TLS_GOTDESC
:
1999 case R_386_TLS_DESC_CALL
:
2000 /* This symbol requires a global offset table entry. */
2002 int tls_type
, old_tls_type
;
2009 tls_type
= GOT_NORMAL
;
2011 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
2012 case R_386_TLS_GOTDESC
:
2013 case R_386_TLS_DESC_CALL
:
2014 tls_type
= GOT_TLS_GDESC
; break;
2015 case R_386_TLS_IE_32
:
2016 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
2017 tls_type
= GOT_TLS_IE_NEG
;
2019 /* If this is a GD->IE transition, we may use either of
2020 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2021 tls_type
= GOT_TLS_IE
;
2024 case R_386_TLS_GOTIE
:
2025 tls_type
= GOT_TLS_IE_POS
; break;
2030 h
->got
.refcount
+= 1;
2031 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2035 bfd_signed_vma
*local_got_refcounts
;
2037 /* This is a global offset table entry for a local symbol. */
2038 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2039 if (local_got_refcounts
== NULL
)
2043 size
= symtab_hdr
->sh_info
;
2044 size
*= (sizeof (bfd_signed_vma
)
2045 + sizeof (bfd_vma
) + sizeof(char));
2046 local_got_refcounts
= (bfd_signed_vma
*)
2047 bfd_zalloc (abfd
, size
);
2048 if (local_got_refcounts
== NULL
)
2050 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2051 elf_i386_local_tlsdesc_gotent (abfd
)
2052 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2053 elf_i386_local_got_tls_type (abfd
)
2054 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2056 local_got_refcounts
[r_symndx
] += 1;
2057 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
2060 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
2061 tls_type
|= old_tls_type
;
2062 /* If a TLS symbol is accessed using IE at least once,
2063 there is no point to use dynamic model for it. */
2064 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2065 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2066 || (tls_type
& GOT_TLS_IE
) == 0))
2068 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
2069 tls_type
= old_tls_type
;
2070 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2071 && GOT_TLS_GD_ANY_P (tls_type
))
2072 tls_type
|= old_tls_type
;
2076 name
= h
->root
.root
.string
;
2078 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2081 /* xgettext:c-format */
2082 (_("%B: `%s' accessed both as normal and "
2083 "thread local symbol"),
2085 bfd_set_error (bfd_error_bad_value
);
2090 if (old_tls_type
!= tls_type
)
2093 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2095 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2103 if (htab
->elf
.sgot
== NULL
)
2105 if (htab
->elf
.dynobj
== NULL
)
2106 htab
->elf
.dynobj
= abfd
;
2107 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
2110 if (r_type
!= R_386_TLS_IE
)
2113 eh
->has_got_reloc
= 1;
2118 case R_386_TLS_LE_32
:
2121 eh
->has_got_reloc
= 1;
2122 if (bfd_link_executable (info
))
2124 info
->flags
|= DF_STATIC_TLS
;
2129 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2130 eh
->has_non_got_reloc
= 1;
2132 /* We are called after all symbols have been resolved. Only
2133 relocation against STT_GNU_IFUNC symbol must go through
2136 && (bfd_link_executable (info
)
2137 || h
->type
== STT_GNU_IFUNC
))
2139 /* If this reloc is in a read-only section, we might
2140 need a copy reloc. We can't check reliably at this
2141 stage whether the section is read-only, as input
2142 sections have not yet been mapped to output sections.
2143 Tentatively set the flag for now, and correct in
2144 adjust_dynamic_symbol. */
2147 /* We may need a .plt entry if the symbol is a function
2148 defined in a shared lib or is a STT_GNU_IFUNC function
2149 referenced from the code or read-only section. */
2151 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2152 h
->plt
.refcount
+= 1;
2154 if (r_type
== R_386_PC32
)
2156 /* Since something like ".long foo - ." may be used
2157 as pointer, make sure that PLT is used if foo is
2158 a function defined in a shared library. */
2159 if ((sec
->flags
& SEC_CODE
) == 0)
2160 h
->pointer_equality_needed
= 1;
2161 else if (h
->type
== STT_GNU_IFUNC
2162 && bfd_link_pic (info
))
2165 name
= h
->root
.root
.string
;
2167 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2170 /* xgettext:c-format */
2171 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2173 bfd_set_error (bfd_error_bad_value
);
2179 h
->pointer_equality_needed
= 1;
2180 /* R_386_32 can be resolved at run-time. */
2181 if (r_type
== R_386_32
2182 && (sec
->flags
& SEC_READONLY
) == 0)
2183 eh
->func_pointer_refcount
+= 1;
2189 /* If we are creating a shared library, and this is a reloc
2190 against a global symbol, or a non PC relative reloc
2191 against a local symbol, then we need to copy the reloc
2192 into the shared library. However, if we are linking with
2193 -Bsymbolic, we do not need to copy a reloc against a
2194 global symbol which is defined in an object we are
2195 including in the link (i.e., DEF_REGULAR is set). At
2196 this point we have not seen all the input files, so it is
2197 possible that DEF_REGULAR is not set now but will be set
2198 later (it is never cleared). In case of a weak definition,
2199 DEF_REGULAR may be cleared later by a strong definition in
2200 a shared library. We account for that possibility below by
2201 storing information in the relocs_copied field of the hash
2202 table entry. A similar situation occurs when creating
2203 shared libraries and symbol visibility changes render the
2206 If on the other hand, we are creating an executable, we
2207 may need to keep relocations for symbols satisfied by a
2208 dynamic library if we manage to avoid copy relocs for the
2211 Generate dynamic pointer relocation against STT_GNU_IFUNC
2212 symbol in the non-code section. */
2213 if ((bfd_link_pic (info
)
2214 && (r_type
!= R_386_PC32
2216 && (! (bfd_link_pie (info
)
2217 || SYMBOLIC_BIND (info
, h
))
2218 || h
->root
.type
== bfd_link_hash_defweak
2219 || !h
->def_regular
))))
2221 && h
->type
== STT_GNU_IFUNC
2222 && r_type
== R_386_32
2223 && (sec
->flags
& SEC_CODE
) == 0)
2224 || (ELIMINATE_COPY_RELOCS
2225 && !bfd_link_pic (info
)
2227 && (h
->root
.type
== bfd_link_hash_defweak
2228 || !h
->def_regular
)))
2230 struct elf_dyn_relocs
*p
;
2231 struct elf_dyn_relocs
**head
;
2233 /* We must copy these reloc types into the output file.
2234 Create a reloc section in dynobj and make room for
2238 if (htab
->elf
.dynobj
== NULL
)
2239 htab
->elf
.dynobj
= abfd
;
2241 sreloc
= _bfd_elf_make_dynamic_reloc_section
2242 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2248 /* If this is a global symbol, we count the number of
2249 relocations we need for this symbol. */
2252 head
= &eh
->dyn_relocs
;
2256 /* Track dynamic relocs needed for local syms too.
2257 We really need local syms available to do this
2262 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2267 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2271 vpp
= &elf_section_data (s
)->local_dynrel
;
2272 head
= (struct elf_dyn_relocs
**)vpp
;
2276 if (p
== NULL
|| p
->sec
!= sec
)
2278 bfd_size_type amt
= sizeof *p
;
2279 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2291 /* Count size relocation as PC-relative relocation. */
2292 if (r_type
== R_386_PC32
|| size_reloc
)
2297 /* This relocation describes the C++ object vtable hierarchy.
2298 Reconstruct it for later use during GC. */
2299 case R_386_GNU_VTINHERIT
:
2300 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2304 /* This relocation describes which C++ vtable entries are actually
2305 used. Record for later use during GC. */
2306 case R_386_GNU_VTENTRY
:
2307 BFD_ASSERT (h
!= NULL
);
2309 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2319 && h
->plt
.refcount
> 0
2320 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2321 || h
->got
.refcount
> 0)
2322 && htab
->plt_got
== NULL
)
2324 /* Create the GOT procedure linkage table. */
2325 unsigned int plt_got_align
;
2326 const struct elf_backend_data
*bed
;
2328 bed
= get_elf_backend_data (info
->output_bfd
);
2329 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
2330 && (sizeof (elf_i386_got_plt_entry
)
2331 == sizeof (elf_i386_pic_got_plt_entry
)));
2334 if (htab
->elf
.dynobj
== NULL
)
2335 htab
->elf
.dynobj
= abfd
;
2337 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2339 (bed
->dynamic_sec_flags
2344 if (htab
->plt_got
== NULL
2345 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2351 if (r_type
== R_386_GOT32X
2352 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2353 sec
->need_convert_load
= 1;
2356 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2358 if (!info
->keep_memory
)
2362 /* Cache the section contents for elf_link_input_bfd. */
2363 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2370 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2372 sec
->check_relocs_failed
= 1;
2376 /* Return the section that should be marked against GC for a given
2380 elf_i386_gc_mark_hook (asection
*sec
,
2381 struct bfd_link_info
*info
,
2382 Elf_Internal_Rela
*rel
,
2383 struct elf_link_hash_entry
*h
,
2384 Elf_Internal_Sym
*sym
)
2387 switch (ELF32_R_TYPE (rel
->r_info
))
2389 case R_386_GNU_VTINHERIT
:
2390 case R_386_GNU_VTENTRY
:
2394 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2397 /* Remove undefined weak symbol from the dynamic symbol table if it
2398 is resolved to 0. */
2401 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2402 struct elf_link_hash_entry
*h
)
2404 if (h
->dynindx
!= -1
2405 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2406 elf_i386_hash_entry (h
)->has_got_reloc
,
2407 elf_i386_hash_entry (h
)))
2410 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2416 /* Adjust a symbol defined by a dynamic object and referenced by a
2417 regular object. The current definition is in some section of the
2418 dynamic object, but we're not including those sections. We have to
2419 change the definition to something the rest of the link can
2423 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2424 struct elf_link_hash_entry
*h
)
2426 struct elf_i386_link_hash_table
*htab
;
2428 struct elf_i386_link_hash_entry
*eh
;
2429 struct elf_dyn_relocs
*p
;
2431 /* STT_GNU_IFUNC symbol must go through PLT. */
2432 if (h
->type
== STT_GNU_IFUNC
)
2434 /* All local STT_GNU_IFUNC references must be treate as local
2435 calls via local PLT. */
2437 && SYMBOL_CALLS_LOCAL (info
, h
))
2439 bfd_size_type pc_count
= 0, count
= 0;
2440 struct elf_dyn_relocs
**pp
;
2442 eh
= (struct elf_i386_link_hash_entry
*) h
;
2443 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2445 pc_count
+= p
->pc_count
;
2446 p
->count
-= p
->pc_count
;
2455 if (pc_count
|| count
)
2460 /* Increment PLT reference count only for PC-relative
2463 if (h
->plt
.refcount
<= 0)
2464 h
->plt
.refcount
= 1;
2466 h
->plt
.refcount
+= 1;
2471 if (h
->plt
.refcount
<= 0)
2473 h
->plt
.offset
= (bfd_vma
) -1;
2479 /* If this is a function, put it in the procedure linkage table. We
2480 will fill in the contents of the procedure linkage table later,
2481 when we know the address of the .got section. */
2482 if (h
->type
== STT_FUNC
2485 if (h
->plt
.refcount
<= 0
2486 || SYMBOL_CALLS_LOCAL (info
, h
)
2487 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2488 && h
->root
.type
== bfd_link_hash_undefweak
))
2490 /* This case can occur if we saw a PLT32 reloc in an input
2491 file, but the symbol was never referred to by a dynamic
2492 object, or if all references were garbage collected. In
2493 such a case, we don't actually need to build a procedure
2494 linkage table, and we can just do a PC32 reloc instead. */
2495 h
->plt
.offset
= (bfd_vma
) -1;
2502 /* It's possible that we incorrectly decided a .plt reloc was
2503 needed for an R_386_PC32 reloc to a non-function sym in
2504 check_relocs. We can't decide accurately between function and
2505 non-function syms in check-relocs; Objects loaded later in
2506 the link may change h->type. So fix it now. */
2507 h
->plt
.offset
= (bfd_vma
) -1;
2509 /* If this is a weak symbol, and there is a real definition, the
2510 processor independent code will have arranged for us to see the
2511 real definition first, and we can just use the same value. */
2512 if (h
->u
.weakdef
!= NULL
)
2514 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2515 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2516 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2517 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2518 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2519 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2523 /* This is a reference to a symbol defined by a dynamic object which
2524 is not a function. */
2526 /* If we are creating a shared library, we must presume that the
2527 only references to the symbol are via the global offset table.
2528 For such cases we need not do anything here; the relocations will
2529 be handled correctly by relocate_section. */
2530 if (!bfd_link_executable (info
))
2533 /* If there are no references to this symbol that do not use the
2534 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2536 eh
= (struct elf_i386_link_hash_entry
*) h
;
2537 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2540 /* If -z nocopyreloc was given, we won't generate them either. */
2541 if (info
->nocopyreloc
)
2547 htab
= elf_i386_hash_table (info
);
2551 /* If there aren't any dynamic relocs in read-only sections nor
2552 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2553 avoid the copy reloc. This doesn't work on VxWorks, where we can
2554 not have dynamic relocations (other than copy and jump slot
2555 relocations) in an executable. */
2556 if (ELIMINATE_COPY_RELOCS
2558 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2560 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2562 s
= p
->sec
->output_section
;
2563 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2574 /* We must allocate the symbol in our .dynbss section, which will
2575 become part of the .bss section of the executable. There will be
2576 an entry for this symbol in the .dynsym section. The dynamic
2577 object will contain position independent code, so all references
2578 from the dynamic object to this symbol will go through the global
2579 offset table. The dynamic linker will use the .dynsym entry to
2580 determine the address it must put in the global offset table, so
2581 both the dynamic object and the regular object will refer to the
2582 same memory location for the variable. */
2584 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2585 copy the initial value out of the dynamic object and into the
2586 runtime process image. */
2587 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2589 s
= htab
->elf
.sdynrelro
;
2590 srel
= htab
->elf
.sreldynrelro
;
2594 s
= htab
->elf
.sdynbss
;
2595 srel
= htab
->elf
.srelbss
;
2597 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2599 srel
->size
+= sizeof (Elf32_External_Rel
);
2603 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2606 /* Allocate space in .plt, .got and associated reloc sections for
2610 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2612 struct bfd_link_info
*info
;
2613 struct elf_i386_link_hash_table
*htab
;
2614 struct elf_i386_link_hash_entry
*eh
;
2615 struct elf_dyn_relocs
*p
;
2616 unsigned plt_entry_size
;
2617 bfd_boolean resolved_to_zero
;
2619 if (h
->root
.type
== bfd_link_hash_indirect
)
2622 eh
= (struct elf_i386_link_hash_entry
*) h
;
2624 info
= (struct bfd_link_info
*) inf
;
2625 htab
= elf_i386_hash_table (info
);
2629 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2631 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2635 /* Clear the reference count of function pointer relocations if
2636 symbol isn't a normal function. */
2637 if (h
->type
!= STT_FUNC
)
2638 eh
->func_pointer_refcount
= 0;
2640 /* We can't use the GOT PLT if pointer equality is needed since
2641 finish_dynamic_symbol won't clear symbol value and the dynamic
2642 linker won't update the GOT slot. We will get into an infinite
2643 loop at run-time. */
2644 if (htab
->plt_got
!= NULL
2645 && h
->type
!= STT_GNU_IFUNC
2646 && !h
->pointer_equality_needed
2647 && h
->plt
.refcount
> 0
2648 && h
->got
.refcount
> 0)
2650 /* Don't use the regular PLT if there are both GOT and GOTPLT
2652 h
->plt
.offset
= (bfd_vma
) -1;
2654 /* Use the GOT PLT. */
2655 eh
->plt_got
.refcount
= 1;
2658 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2659 here if it is defined and referenced in a non-shared object. */
2660 if (h
->type
== STT_GNU_IFUNC
2662 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2663 &htab
->readonly_dynrelocs_against_ifunc
,
2665 plt_entry_size
, 4, TRUE
);
2666 /* Don't create the PLT entry if there are only function pointer
2667 relocations which can be resolved at run-time. */
2668 else if (htab
->elf
.dynamic_sections_created
2669 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2670 || eh
->plt_got
.refcount
> 0))
2672 bfd_boolean use_plt_got
;
2674 /* Clear the reference count of function pointer relocations
2676 eh
->func_pointer_refcount
= 0;
2678 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2680 /* Don't use the regular PLT for DF_BIND_NOW. */
2681 h
->plt
.offset
= (bfd_vma
) -1;
2683 /* Use the GOT PLT. */
2684 h
->got
.refcount
= 1;
2685 eh
->plt_got
.refcount
= 1;
2688 use_plt_got
= eh
->plt_got
.refcount
> 0;
2690 /* Make sure this symbol is output as a dynamic symbol.
2691 Undefined weak syms won't yet be marked as dynamic. */
2692 if (h
->dynindx
== -1
2694 && !resolved_to_zero
)
2696 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2700 if (bfd_link_pic (info
)
2701 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2703 asection
*s
= htab
->elf
.splt
;
2704 asection
*got_s
= htab
->plt_got
;
2706 /* If this is the first .plt entry, make room for the special
2707 first entry. The .plt section is used by prelink to undo
2708 prelinking for dynamic relocations. */
2710 s
->size
= plt_entry_size
;
2713 eh
->plt_got
.offset
= got_s
->size
;
2715 h
->plt
.offset
= s
->size
;
2717 /* If this symbol is not defined in a regular file, and we are
2718 not generating a shared library, then set the symbol to this
2719 location in the .plt. This is required to make function
2720 pointers compare as equal between the normal executable and
2721 the shared library. */
2722 if (! bfd_link_pic (info
)
2727 /* We need to make a call to the entry of the GOT PLT
2728 instead of regular PLT entry. */
2729 h
->root
.u
.def
.section
= got_s
;
2730 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2734 h
->root
.u
.def
.section
= s
;
2735 h
->root
.u
.def
.value
= h
->plt
.offset
;
2739 /* Make room for this entry. */
2741 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2744 s
->size
+= plt_entry_size
;
2746 /* We also need to make an entry in the .got.plt section,
2747 which will be placed in the .got section by the linker
2749 htab
->elf
.sgotplt
->size
+= 4;
2751 /* There should be no PLT relocation against resolved
2752 undefined weak symbol in executable. */
2753 if (!resolved_to_zero
)
2755 /* We also need to make an entry in the .rel.plt
2757 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2758 htab
->elf
.srelplt
->reloc_count
++;
2762 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2763 && !bfd_link_pic (info
))
2765 /* VxWorks has a second set of relocations for each PLT entry
2766 in executables. They go in a separate relocation section,
2767 which is processed by the kernel loader. */
2769 /* There are two relocations for the initial PLT entry: an
2770 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2771 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2773 if (h
->plt
.offset
== plt_entry_size
)
2774 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2776 /* There are two extra relocations for each subsequent PLT entry:
2777 an R_386_32 relocation for the GOT entry, and an R_386_32
2778 relocation for the PLT entry. */
2780 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2785 eh
->plt_got
.offset
= (bfd_vma
) -1;
2786 h
->plt
.offset
= (bfd_vma
) -1;
2792 eh
->plt_got
.offset
= (bfd_vma
) -1;
2793 h
->plt
.offset
= (bfd_vma
) -1;
2797 eh
->tlsdesc_got
= (bfd_vma
) -1;
2799 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2800 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2801 if (h
->got
.refcount
> 0
2802 && bfd_link_executable (info
)
2804 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2805 h
->got
.offset
= (bfd_vma
) -1;
2806 else if (h
->got
.refcount
> 0)
2810 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2812 /* Make sure this symbol is output as a dynamic symbol.
2813 Undefined weak syms won't yet be marked as dynamic. */
2814 if (h
->dynindx
== -1
2816 && !resolved_to_zero
)
2818 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2823 if (GOT_TLS_GDESC_P (tls_type
))
2825 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2826 - elf_i386_compute_jump_table_size (htab
);
2827 htab
->elf
.sgotplt
->size
+= 8;
2828 h
->got
.offset
= (bfd_vma
) -2;
2830 if (! GOT_TLS_GDESC_P (tls_type
)
2831 || GOT_TLS_GD_P (tls_type
))
2833 h
->got
.offset
= s
->size
;
2835 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2836 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2839 dyn
= htab
->elf
.dynamic_sections_created
;
2840 /* R_386_TLS_IE_32 needs one dynamic relocation,
2841 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2842 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2843 need two), R_386_TLS_GD needs one if local symbol and two if
2844 global. No dynamic relocation against resolved undefined weak
2845 symbol in executable. */
2846 if (tls_type
== GOT_TLS_IE_BOTH
)
2847 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2848 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2849 || (tls_type
& GOT_TLS_IE
))
2850 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2851 else if (GOT_TLS_GD_P (tls_type
))
2852 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2853 else if (! GOT_TLS_GDESC_P (tls_type
)
2854 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2855 && !resolved_to_zero
)
2856 || h
->root
.type
!= bfd_link_hash_undefweak
)
2857 && (bfd_link_pic (info
)
2858 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2859 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2860 if (GOT_TLS_GDESC_P (tls_type
))
2861 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2864 h
->got
.offset
= (bfd_vma
) -1;
2866 if (eh
->dyn_relocs
== NULL
)
2869 /* In the shared -Bsymbolic case, discard space allocated for
2870 dynamic pc-relative relocs against symbols which turn out to be
2871 defined in regular objects. For the normal shared case, discard
2872 space for pc-relative relocs that have become local due to symbol
2873 visibility changes. */
2875 if (bfd_link_pic (info
))
2877 /* The only reloc that uses pc_count is R_386_PC32, which will
2878 appear on a call or on something like ".long foo - .". We
2879 want calls to protected symbols to resolve directly to the
2880 function rather than going via the plt. If people want
2881 function pointer comparisons to work as expected then they
2882 should avoid writing assembly like ".long foo - .". */
2883 if (SYMBOL_CALLS_LOCAL (info
, h
))
2885 struct elf_dyn_relocs
**pp
;
2887 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2889 p
->count
-= p
->pc_count
;
2898 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2900 struct elf_dyn_relocs
**pp
;
2901 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2903 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2910 /* Also discard relocs on undefined weak syms with non-default
2911 visibility or in PIE. */
2912 if (eh
->dyn_relocs
!= NULL
2913 && h
->root
.type
== bfd_link_hash_undefweak
)
2915 /* Undefined weak symbol is never bound locally in shared
2917 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2918 || resolved_to_zero
)
2922 /* Keep dynamic non-GOT/non-PLT relocation so that we
2923 can branch to 0 without PLT. */
2924 struct elf_dyn_relocs
**pp
;
2926 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2927 if (p
->pc_count
== 0)
2931 /* Remove non-R_386_PC32 relocation. */
2932 p
->count
= p
->pc_count
;
2936 if (eh
->dyn_relocs
!= NULL
)
2938 /* Make sure undefined weak symbols are output
2939 as dynamic symbols in PIEs for dynamic non-GOT
2940 non-PLT reloations. */
2941 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2946 eh
->dyn_relocs
= NULL
;
2948 else if (h
->dynindx
== -1
2949 && !h
->forced_local
)
2951 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2956 else if (ELIMINATE_COPY_RELOCS
)
2958 /* For the non-shared case, discard space for relocs against
2959 symbols which turn out to need copy relocs or are not
2960 dynamic. Keep dynamic relocations for run-time function
2961 pointer initialization. */
2963 if ((!h
->non_got_ref
2964 || eh
->func_pointer_refcount
> 0
2965 || (h
->root
.type
== bfd_link_hash_undefweak
2966 && !resolved_to_zero
))
2969 || (htab
->elf
.dynamic_sections_created
2970 && (h
->root
.type
== bfd_link_hash_undefweak
2971 || h
->root
.type
== bfd_link_hash_undefined
))))
2973 /* Make sure this symbol is output as a dynamic symbol.
2974 Undefined weak syms won't yet be marked as dynamic. */
2975 if (h
->dynindx
== -1
2977 && !resolved_to_zero
)
2979 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2983 /* If that succeeded, we know we'll be keeping all the
2985 if (h
->dynindx
!= -1)
2989 eh
->dyn_relocs
= NULL
;
2990 eh
->func_pointer_refcount
= 0;
2995 /* Finally, allocate space. */
2996 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3000 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3002 BFD_ASSERT (sreloc
!= NULL
);
3003 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3009 /* Allocate space in .plt, .got and associated reloc sections for
3010 local dynamic relocs. */
3013 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
3015 struct elf_link_hash_entry
*h
3016 = (struct elf_link_hash_entry
*) *slot
;
3018 if (h
->type
!= STT_GNU_IFUNC
3022 || h
->root
.type
!= bfd_link_hash_defined
)
3025 return elf_i386_allocate_dynrelocs (h
, inf
);
3028 /* Find any dynamic relocs that apply to read-only sections. */
3031 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3033 struct elf_i386_link_hash_entry
*eh
;
3034 struct elf_dyn_relocs
*p
;
3036 /* Skip local IFUNC symbols. */
3037 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3040 eh
= (struct elf_i386_link_hash_entry
*) h
;
3041 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3043 asection
*s
= p
->sec
->output_section
;
3045 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3047 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3049 info
->flags
|= DF_TEXTREL
;
3051 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3052 || info
->error_textrel
)
3053 /* xgettext:c-format */
3054 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3055 p
->sec
->owner
, h
->root
.root
.string
,
3058 /* Not an error, just cut short the traversal. */
3065 /* Convert load via the GOT slot to load immediate. */
3068 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
3069 struct bfd_link_info
*link_info
)
3071 struct elf_i386_link_hash_table
*htab
;
3072 Elf_Internal_Shdr
*symtab_hdr
;
3073 Elf_Internal_Rela
*internal_relocs
;
3074 Elf_Internal_Rela
*irel
, *irelend
;
3076 bfd_boolean changed
;
3077 bfd_signed_vma
*local_got_refcounts
;
3079 /* Don't even try to convert non-ELF outputs. */
3080 if (!is_elf_hash_table (link_info
->hash
))
3083 /* Nothing to do if there is no need or no output. */
3084 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3085 || sec
->need_convert_load
== 0
3086 || bfd_is_abs_section (sec
->output_section
))
3089 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3091 /* Load the relocations for this section. */
3092 internal_relocs
= (_bfd_elf_link_read_relocs
3093 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3094 link_info
->keep_memory
));
3095 if (internal_relocs
== NULL
)
3099 htab
= elf_i386_hash_table (link_info
);
3100 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3102 /* Get the section contents. */
3103 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3104 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3107 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3111 irelend
= internal_relocs
+ sec
->reloc_count
;
3112 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3114 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3115 unsigned int r_symndx
;
3116 struct elf_link_hash_entry
*h
;
3117 bfd_boolean converted
;
3119 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3120 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3121 if (r_type
!= R_386_GOT32X
)
3124 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3125 if (r_symndx
< symtab_hdr
->sh_info
)
3126 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3127 (const Elf_Internal_Rela
*) irel
,
3131 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3132 while (h
->root
.type
== bfd_link_hash_indirect
3133 || h
->root
.type
== bfd_link_hash_warning
)
3134 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3137 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3138 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3142 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3143 irel
, h
, &converted
, link_info
))
3148 changed
= converted
;
3151 if (h
->got
.refcount
> 0)
3152 h
->got
.refcount
-= 1;
3156 if (local_got_refcounts
!= NULL
3157 && local_got_refcounts
[r_symndx
] > 0)
3158 local_got_refcounts
[r_symndx
] -= 1;
3163 if (contents
!= NULL
3164 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3166 if (!changed
&& !link_info
->keep_memory
)
3170 /* Cache the section contents for elf_link_input_bfd. */
3171 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3175 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3178 free (internal_relocs
);
3180 elf_section_data (sec
)->relocs
= internal_relocs
;
3186 if (contents
!= NULL
3187 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3189 if (internal_relocs
!= NULL
3190 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3191 free (internal_relocs
);
3195 /* Set the sizes of the dynamic sections. */
3198 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3200 struct elf_i386_link_hash_table
*htab
;
3206 htab
= elf_i386_hash_table (info
);
3209 dynobj
= htab
->elf
.dynobj
;
3213 /* Set up .got offsets for local syms, and space for local dynamic
3215 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3217 bfd_signed_vma
*local_got
;
3218 bfd_signed_vma
*end_local_got
;
3219 char *local_tls_type
;
3220 bfd_vma
*local_tlsdesc_gotent
;
3221 bfd_size_type locsymcount
;
3222 Elf_Internal_Shdr
*symtab_hdr
;
3225 if (! is_i386_elf (ibfd
))
3228 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3230 struct elf_dyn_relocs
*p
;
3232 if (!elf_i386_convert_load (ibfd
, s
, info
))
3235 for (p
= ((struct elf_dyn_relocs
*)
3236 elf_section_data (s
)->local_dynrel
);
3240 if (!bfd_is_abs_section (p
->sec
)
3241 && bfd_is_abs_section (p
->sec
->output_section
))
3243 /* Input section has been discarded, either because
3244 it is a copy of a linkonce section or due to
3245 linker script /DISCARD/, so we'll be discarding
3248 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3249 && strcmp (p
->sec
->output_section
->name
,
3252 /* Relocations in vxworks .tls_vars sections are
3253 handled specially by the loader. */
3255 else if (p
->count
!= 0)
3257 srel
= elf_section_data (p
->sec
)->sreloc
;
3258 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3259 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3260 && (info
->flags
& DF_TEXTREL
) == 0)
3262 info
->flags
|= DF_TEXTREL
;
3263 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3264 || info
->error_textrel
)
3265 /* xgettext:c-format */
3266 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3267 p
->sec
->owner
, p
->sec
);
3273 local_got
= elf_local_got_refcounts (ibfd
);
3277 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3278 locsymcount
= symtab_hdr
->sh_info
;
3279 end_local_got
= local_got
+ locsymcount
;
3280 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3281 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3283 srel
= htab
->elf
.srelgot
;
3284 for (; local_got
< end_local_got
;
3285 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3287 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3290 if (GOT_TLS_GDESC_P (*local_tls_type
))
3292 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3293 - elf_i386_compute_jump_table_size (htab
);
3294 htab
->elf
.sgotplt
->size
+= 8;
3295 *local_got
= (bfd_vma
) -2;
3297 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3298 || GOT_TLS_GD_P (*local_tls_type
))
3300 *local_got
= s
->size
;
3302 if (GOT_TLS_GD_P (*local_tls_type
)
3303 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3306 if (bfd_link_pic (info
)
3307 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3308 || (*local_tls_type
& GOT_TLS_IE
))
3310 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3311 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3312 else if (GOT_TLS_GD_P (*local_tls_type
)
3313 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3314 srel
->size
+= sizeof (Elf32_External_Rel
);
3315 if (GOT_TLS_GDESC_P (*local_tls_type
))
3316 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3320 *local_got
= (bfd_vma
) -1;
3324 if (htab
->tls_ldm_got
.refcount
> 0)
3326 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3328 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3329 htab
->elf
.sgot
->size
+= 8;
3330 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3333 htab
->tls_ldm_got
.offset
= -1;
3335 /* Allocate global sym .plt and .got entries, and space for global
3336 sym dynamic relocs. */
3337 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3339 /* Allocate .plt and .got entries, and space for local symbols. */
3340 htab_traverse (htab
->loc_hash_table
,
3341 elf_i386_allocate_local_dynrelocs
,
3344 /* For every jump slot reserved in the sgotplt, reloc_count is
3345 incremented. However, when we reserve space for TLS descriptors,
3346 it's not incremented, so in order to compute the space reserved
3347 for them, it suffices to multiply the reloc count by the jump
3350 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3351 so that R_386_IRELATIVE entries come last. */
3352 if (htab
->elf
.srelplt
)
3354 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3355 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3356 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3358 else if (htab
->elf
.irelplt
)
3359 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3362 if (htab
->elf
.sgotplt
)
3364 /* Don't allocate .got.plt section if there are no GOT nor PLT
3365 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3366 if ((htab
->elf
.hgot
== NULL
3367 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3368 && (htab
->elf
.sgotplt
->size
3369 == get_elf_backend_data (output_bfd
)->got_header_size
)
3370 && (htab
->elf
.splt
== NULL
3371 || htab
->elf
.splt
->size
== 0)
3372 && (htab
->elf
.sgot
== NULL
3373 || htab
->elf
.sgot
->size
== 0)
3374 && (htab
->elf
.iplt
== NULL
3375 || htab
->elf
.iplt
->size
== 0)
3376 && (htab
->elf
.igotplt
== NULL
3377 || htab
->elf
.igotplt
->size
== 0))
3378 htab
->elf
.sgotplt
->size
= 0;
3382 if (htab
->plt_eh_frame
!= NULL
3383 && htab
->elf
.splt
!= NULL
3384 && htab
->elf
.splt
->size
!= 0
3385 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3386 && _bfd_elf_eh_frame_present (info
))
3387 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3389 /* We now have determined the sizes of the various dynamic sections.
3390 Allocate memory for them. */
3392 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3394 bfd_boolean strip_section
= TRUE
;
3396 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3399 if (s
== htab
->elf
.splt
3400 || s
== htab
->elf
.sgot
)
3402 /* Strip this section if we don't need it; see the
3404 /* We'd like to strip these sections if they aren't needed, but if
3405 we've exported dynamic symbols from them we must leave them.
3406 It's too late to tell BFD to get rid of the symbols. */
3408 if (htab
->elf
.hplt
!= NULL
)
3409 strip_section
= FALSE
;
3411 else if (s
== htab
->elf
.sgotplt
3412 || s
== htab
->elf
.iplt
3413 || s
== htab
->elf
.igotplt
3414 || s
== htab
->plt_got
3415 || s
== htab
->plt_eh_frame
3416 || s
== htab
->elf
.sdynbss
3417 || s
== htab
->elf
.sdynrelro
)
3419 /* Strip these too. */
3421 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3424 && s
!= htab
->elf
.srelplt
3425 && s
!= htab
->srelplt2
)
3428 /* We use the reloc_count field as a counter if we need
3429 to copy relocs into the output file. */
3434 /* It's not one of our sections, so don't allocate space. */
3440 /* If we don't need this section, strip it from the
3441 output file. This is mostly to handle .rel.bss and
3442 .rel.plt. We must create both sections in
3443 create_dynamic_sections, because they must be created
3444 before the linker maps input sections to output
3445 sections. The linker does that before
3446 adjust_dynamic_symbol is called, and it is that
3447 function which decides whether anything needs to go
3448 into these sections. */
3450 s
->flags
|= SEC_EXCLUDE
;
3454 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3457 /* Allocate memory for the section contents. We use bfd_zalloc
3458 here in case unused entries are not reclaimed before the
3459 section's contents are written out. This should not happen,
3460 but this way if it does, we get a R_386_NONE reloc instead
3462 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3463 if (s
->contents
== NULL
)
3467 if (htab
->plt_eh_frame
!= NULL
3468 && htab
->plt_eh_frame
->contents
!= NULL
)
3470 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3471 sizeof (elf_i386_eh_frame_plt
));
3472 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3473 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3476 if (htab
->elf
.dynamic_sections_created
)
3478 /* Add some entries to the .dynamic section. We fill in the
3479 values later, in elf_i386_finish_dynamic_sections, but we
3480 must add the entries now so that we get the correct size for
3481 the .dynamic section. The DT_DEBUG entry is filled in by the
3482 dynamic linker and used by the debugger. */
3483 #define add_dynamic_entry(TAG, VAL) \
3484 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3486 if (bfd_link_executable (info
))
3488 if (!add_dynamic_entry (DT_DEBUG
, 0))
3492 if (htab
->elf
.splt
->size
!= 0)
3494 /* DT_PLTGOT is used by prelink even if there is no PLT
3496 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))
3510 if (!add_dynamic_entry (DT_REL
, 0)
3511 || !add_dynamic_entry (DT_RELSZ
, 0)
3512 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3515 /* If any dynamic relocs apply to a read-only section,
3516 then we need a DT_TEXTREL entry. */
3517 if ((info
->flags
& DF_TEXTREL
) == 0)
3518 elf_link_hash_traverse (&htab
->elf
,
3519 elf_i386_readonly_dynrelocs
, info
);
3521 if ((info
->flags
& DF_TEXTREL
) != 0)
3523 if (htab
->readonly_dynrelocs_against_ifunc
)
3525 info
->callbacks
->einfo
3526 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3527 bfd_set_error (bfd_error_bad_value
);
3531 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3535 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3536 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3539 #undef add_dynamic_entry
3545 elf_i386_always_size_sections (bfd
*output_bfd
,
3546 struct bfd_link_info
*info
)
3548 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3552 struct elf_link_hash_entry
*tlsbase
;
3554 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3555 "_TLS_MODULE_BASE_",
3556 FALSE
, FALSE
, FALSE
);
3558 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3560 struct elf_i386_link_hash_table
*htab
;
3561 struct bfd_link_hash_entry
*bh
= NULL
;
3562 const struct elf_backend_data
*bed
3563 = get_elf_backend_data (output_bfd
);
3565 htab
= elf_i386_hash_table (info
);
3569 if (!(_bfd_generic_link_add_one_symbol
3570 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3571 tls_sec
, 0, NULL
, FALSE
,
3572 bed
->collect
, &bh
)))
3575 htab
->tls_module_base
= bh
;
3577 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3578 tlsbase
->def_regular
= 1;
3579 tlsbase
->other
= STV_HIDDEN
;
3580 tlsbase
->root
.linker_def
= 1;
3581 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3588 /* Set the correct type for an x86 ELF section. We do this by the
3589 section name, which is a hack, but ought to work. */
3592 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3593 Elf_Internal_Shdr
*hdr
,
3598 name
= bfd_get_section_name (abfd
, sec
);
3600 /* This is an ugly, but unfortunately necessary hack that is
3601 needed when producing EFI binaries on x86. It tells
3602 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3603 containing ELF relocation info. We need this hack in order to
3604 be able to generate ELF binaries that can be translated into
3605 EFI applications (which are essentially COFF objects). Those
3606 files contain a COFF ".reloc" section inside an ELFNN object,
3607 which would normally cause BFD to segfault because it would
3608 attempt to interpret this section as containing relocation
3609 entries for section "oc". With this hack enabled, ".reloc"
3610 will be treated as a normal data section, which will avoid the
3611 segfault. However, you won't be able to create an ELFNN binary
3612 with a section named "oc" that needs relocations, but that's
3613 the kind of ugly side-effects you get when detecting section
3614 types based on their names... In practice, this limitation is
3615 unlikely to bite. */
3616 if (strcmp (name
, ".reloc") == 0)
3617 hdr
->sh_type
= SHT_PROGBITS
;
3622 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3623 executables. Rather than setting it to the beginning of the TLS
3624 section, we have to set it to the end. This function may be called
3625 multiple times, it is idempotent. */
3628 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3630 struct elf_i386_link_hash_table
*htab
;
3631 struct bfd_link_hash_entry
*base
;
3633 if (!bfd_link_executable (info
))
3636 htab
= elf_i386_hash_table (info
);
3640 base
= htab
->tls_module_base
;
3644 base
->u
.def
.value
= htab
->elf
.tls_size
;
3647 /* Return the base VMA address which should be subtracted from real addresses
3648 when resolving @dtpoff relocation.
3649 This is PT_TLS segment p_vaddr. */
3652 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3654 /* If tls_sec is NULL, we should have signalled an error already. */
3655 if (elf_hash_table (info
)->tls_sec
== NULL
)
3657 return elf_hash_table (info
)->tls_sec
->vma
;
3660 /* Return the relocation value for @tpoff relocation
3661 if STT_TLS virtual address is ADDRESS. */
3664 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3666 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3667 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3668 bfd_vma static_tls_size
;
3670 /* If tls_sec is NULL, we should have signalled an error already. */
3671 if (htab
->tls_sec
== NULL
)
3674 /* Consider special static TLS alignment requirements. */
3675 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3676 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3679 /* Relocate an i386 ELF section. */
3682 elf_i386_relocate_section (bfd
*output_bfd
,
3683 struct bfd_link_info
*info
,
3685 asection
*input_section
,
3687 Elf_Internal_Rela
*relocs
,
3688 Elf_Internal_Sym
*local_syms
,
3689 asection
**local_sections
)
3691 struct elf_i386_link_hash_table
*htab
;
3692 Elf_Internal_Shdr
*symtab_hdr
;
3693 struct elf_link_hash_entry
**sym_hashes
;
3694 bfd_vma
*local_got_offsets
;
3695 bfd_vma
*local_tlsdesc_gotents
;
3696 Elf_Internal_Rela
*rel
;
3697 Elf_Internal_Rela
*wrel
;
3698 Elf_Internal_Rela
*relend
;
3699 bfd_boolean is_vxworks_tls
;
3700 unsigned plt_entry_size
;
3702 BFD_ASSERT (is_i386_elf (input_bfd
));
3704 /* Skip if check_relocs failed. */
3705 if (input_section
->check_relocs_failed
)
3708 htab
= elf_i386_hash_table (info
);
3711 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3712 sym_hashes
= elf_sym_hashes (input_bfd
);
3713 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3714 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3715 /* We have to handle relocations in vxworks .tls_vars sections
3716 specially, because the dynamic loader is 'weird'. */
3717 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3718 && bfd_link_pic (info
)
3719 && !strcmp (input_section
->output_section
->name
,
3722 elf_i386_set_tls_module_base (info
);
3724 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
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
;
3747 r_type
= ELF32_R_TYPE (rel
->r_info
);
3748 if (r_type
== R_386_GNU_VTINHERIT
3749 || r_type
== R_386_GNU_VTENTRY
)
3756 if ((indx
= r_type
) >= R_386_standard
3757 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3758 >= R_386_ext
- R_386_standard
)
3759 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3760 >= R_386_ext2
- R_386_ext
))
3763 /* xgettext:c-format */
3764 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3765 input_bfd
, input_section
, r_type
);
3766 bfd_set_error (bfd_error_bad_value
);
3769 howto
= elf_howto_table
+ indx
;
3771 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3775 unresolved_reloc
= FALSE
;
3776 if (r_symndx
< symtab_hdr
->sh_info
)
3778 sym
= local_syms
+ r_symndx
;
3779 sec
= local_sections
[r_symndx
];
3780 relocation
= (sec
->output_section
->vma
3781 + sec
->output_offset
3783 st_size
= sym
->st_size
;
3785 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3786 && ((sec
->flags
& SEC_MERGE
) != 0
3787 || (bfd_link_relocatable (info
)
3788 && sec
->output_offset
!= 0)))
3791 bfd_byte
*where
= contents
+ rel
->r_offset
;
3793 switch (howto
->size
)
3796 addend
= bfd_get_8 (input_bfd
, where
);
3797 if (howto
->pc_relative
)
3799 addend
= (addend
^ 0x80) - 0x80;
3804 addend
= bfd_get_16 (input_bfd
, where
);
3805 if (howto
->pc_relative
)
3807 addend
= (addend
^ 0x8000) - 0x8000;
3812 addend
= bfd_get_32 (input_bfd
, where
);
3813 if (howto
->pc_relative
)
3815 addend
= (addend
^ 0x80000000) - 0x80000000;
3823 if (bfd_link_relocatable (info
))
3824 addend
+= sec
->output_offset
;
3827 asection
*msec
= sec
;
3828 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3830 addend
-= relocation
;
3831 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3834 switch (howto
->size
)
3837 /* FIXME: overflow checks. */
3838 if (howto
->pc_relative
)
3840 bfd_put_8 (input_bfd
, addend
, where
);
3843 if (howto
->pc_relative
)
3845 bfd_put_16 (input_bfd
, addend
, where
);
3848 if (howto
->pc_relative
)
3850 bfd_put_32 (input_bfd
, addend
, where
);
3854 else if (!bfd_link_relocatable (info
)
3855 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3857 /* Relocate against local STT_GNU_IFUNC symbol. */
3858 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3863 /* Set STT_GNU_IFUNC symbol value. */
3864 h
->root
.u
.def
.value
= sym
->st_value
;
3865 h
->root
.u
.def
.section
= sec
;
3870 bfd_boolean warned ATTRIBUTE_UNUSED
;
3871 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3873 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3874 r_symndx
, symtab_hdr
, sym_hashes
,
3876 unresolved_reloc
, warned
, ignored
);
3880 if (sec
!= NULL
&& discarded_section (sec
))
3882 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3883 contents
+ rel
->r_offset
);
3884 wrel
->r_offset
= rel
->r_offset
;
3888 /* For ld -r, remove relocations in debug sections against
3889 sections defined in discarded sections. Not done for
3890 eh_frame editing code expects to be present. */
3891 if (bfd_link_relocatable (info
)
3892 && (input_section
->flags
& SEC_DEBUGGING
))
3898 if (bfd_link_relocatable (info
))
3905 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3906 it here if it is defined in a non-shared object. */
3908 && h
->type
== STT_GNU_IFUNC
3911 asection
*plt
, *gotplt
, *base_got
;
3915 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3917 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3918 sections because such sections are not SEC_ALLOC and
3919 thus ld.so will not process them. */
3920 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3925 /* STT_GNU_IFUNC symbol must go through PLT. */
3926 if (htab
->elf
.splt
!= NULL
)
3928 plt
= htab
->elf
.splt
;
3929 gotplt
= htab
->elf
.sgotplt
;
3933 plt
= htab
->elf
.iplt
;
3934 gotplt
= htab
->elf
.igotplt
;
3944 base_got
= htab
->elf
.sgot
;
3945 off
= h
->got
.offset
;
3947 if (base_got
== NULL
)
3950 if (off
== (bfd_vma
) -1)
3952 /* We can't use h->got.offset here to save state, or
3953 even just remember the offset, as finish_dynamic_symbol
3954 would use that as offset into .got. */
3956 if (h
->plt
.offset
== (bfd_vma
) -1)
3959 if (htab
->elf
.splt
!= NULL
)
3961 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3962 off
= (plt_index
+ 3) * 4;
3963 base_got
= htab
->elf
.sgotplt
;
3967 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3968 off
= plt_index
* 4;
3969 base_got
= htab
->elf
.igotplt
;
3972 if (h
->dynindx
== -1
3976 /* This references the local defitionion. We must
3977 initialize this entry in the global offset table.
3978 Since the offset must always be a multiple of 8,
3979 we use the least significant bit to record
3980 whether we have initialized it already.
3982 When doing a dynamic link, we create a .rela.got
3983 relocation entry to initialize the value. This
3984 is done in the finish_dynamic_symbol routine. */
3989 bfd_put_32 (output_bfd
, relocation
,
3990 base_got
->contents
+ off
);
3998 relocation
= (base_got
->output_section
->vma
3999 + base_got
->output_offset
+ off
4000 - gotplt
->output_section
->vma
4001 - gotplt
->output_offset
);
4003 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4005 if (bfd_link_pic (info
))
4006 goto disallow_got32
;
4008 /* Add the GOT base if there is no base register. */
4009 relocation
+= (gotplt
->output_section
->vma
4010 + gotplt
->output_offset
);
4012 else if (htab
->elf
.splt
== NULL
)
4014 /* Adjust for static executables. */
4015 relocation
+= gotplt
->output_offset
;
4021 if (h
->plt
.offset
== (bfd_vma
) -1)
4023 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4024 if (r_type
== R_386_32
4025 && (input_section
->flags
& SEC_CODE
) == 0)
4026 goto do_ifunc_pointer
;
4027 goto bad_ifunc_reloc
;
4030 relocation
= (plt
->output_section
->vma
4031 + plt
->output_offset
+ h
->plt
.offset
);
4037 if (h
->root
.root
.string
)
4038 name
= h
->root
.root
.string
;
4040 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4043 /* xgettext:c-format */
4044 (_("%B: relocation %s against STT_GNU_IFUNC "
4045 "symbol `%s' isn't supported"), input_bfd
,
4047 bfd_set_error (bfd_error_bad_value
);
4051 /* Generate dynamic relcoation only when there is a
4052 non-GOT reference in a shared object. */
4053 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4054 || h
->plt
.offset
== (bfd_vma
) -1)
4056 Elf_Internal_Rela outrel
;
4061 /* Need a dynamic relocation to get the real function
4063 offset
= _bfd_elf_section_offset (output_bfd
,
4067 if (offset
== (bfd_vma
) -1
4068 || offset
== (bfd_vma
) -2)
4071 outrel
.r_offset
= (input_section
->output_section
->vma
4072 + input_section
->output_offset
4075 if (h
->dynindx
== -1
4077 || bfd_link_executable (info
))
4079 /* This symbol is resolved locally. */
4080 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4081 bfd_put_32 (output_bfd
,
4082 (h
->root
.u
.def
.value
4083 + h
->root
.u
.def
.section
->output_section
->vma
4084 + h
->root
.u
.def
.section
->output_offset
),
4088 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4090 /* Dynamic relocations are stored in
4091 1. .rel.ifunc section in PIC object.
4092 2. .rel.got section in dynamic executable.
4093 3. .rel.iplt section in static executable. */
4094 if (bfd_link_pic (info
))
4095 sreloc
= htab
->elf
.irelifunc
;
4096 else if (htab
->elf
.splt
!= NULL
)
4097 sreloc
= htab
->elf
.srelgot
;
4099 sreloc
= htab
->elf
.irelplt
;
4100 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4102 /* If this reloc is against an external symbol, we
4103 do not want to fiddle with the addend. Otherwise,
4104 we need to include the symbol value so that it
4105 becomes an addend for the dynamic reloc. For an
4106 internal symbol, we have updated addend. */
4115 relocation
-= (gotplt
->output_section
->vma
4116 + gotplt
->output_offset
);
4121 eh
= (struct elf_i386_link_hash_entry
*) h
;
4122 resolved_to_zero
= (eh
!= NULL
4123 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4130 /* Avoid optimizing _DYNAMIC since ld.so may use its
4131 link-time address. */
4132 if (h
== htab
->elf
.hdynamic
)
4135 if (bfd_link_pic (info
))
4137 /* It is OK to convert mov to lea and convert indirect
4138 branch to direct branch. It is OK to convert adc,
4139 add, and, cmp, or, sbb, sub, test, xor only when PIC
4141 unsigned int opcode
, addend
;
4142 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4145 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4146 if (opcode
!= 0x8b && opcode
!= 0xff)
4150 /* Resolve "mov GOT[(%reg)], %reg",
4151 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4152 and "binop foo@GOT[(%reg)], %reg". */
4154 || (h
->plt
.offset
== (bfd_vma
) -1
4155 && h
->got
.offset
== (bfd_vma
) -1)
4156 || htab
->elf
.sgotplt
== NULL
)
4159 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4160 + htab
->elf
.sgotplt
->output_offset
);
4162 /* It is relative to .got.plt section. */
4163 if (h
->got
.offset
!= (bfd_vma
) -1)
4164 /* Use GOT entry. Mask off the least significant bit in
4165 GOT offset which may be set by R_386_GOT32 processing
4167 relocation
= (htab
->elf
.sgot
->output_section
->vma
4168 + htab
->elf
.sgot
->output_offset
4169 + (h
->got
.offset
& ~1) - offplt
);
4171 /* Use GOTPLT entry. */
4172 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4174 if (!bfd_link_pic (info
))
4176 /* If not PIC, add the .got.plt section address for
4177 baseless addressing. */
4179 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4180 if ((modrm
& 0xc7) == 0x5)
4181 relocation
+= offplt
;
4184 unresolved_reloc
= FALSE
;
4189 /* Relocation is to the entry for this symbol in the global
4191 if (htab
->elf
.sgot
== NULL
)
4198 off
= h
->got
.offset
;
4199 dyn
= htab
->elf
.dynamic_sections_created
;
4200 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4201 bfd_link_pic (info
),
4203 || (bfd_link_pic (info
)
4204 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4205 || (ELF_ST_VISIBILITY (h
->other
)
4206 && h
->root
.type
== bfd_link_hash_undefweak
))
4208 /* This is actually a static link, or it is a
4209 -Bsymbolic link and the symbol is defined
4210 locally, or the symbol was forced to be local
4211 because of a version file. We must initialize
4212 this entry in the global offset table. Since the
4213 offset must always be a multiple of 4, we use the
4214 least significant bit to record whether we have
4215 initialized it already.
4217 When doing a dynamic link, we create a .rel.got
4218 relocation entry to initialize the value. This
4219 is done in the finish_dynamic_symbol routine. */
4224 bfd_put_32 (output_bfd
, relocation
,
4225 htab
->elf
.sgot
->contents
+ off
);
4230 unresolved_reloc
= FALSE
;
4234 if (local_got_offsets
== NULL
)
4237 off
= local_got_offsets
[r_symndx
];
4239 /* The offset must always be a multiple of 4. We use
4240 the least significant bit to record whether we have
4241 already generated the necessary reloc. */
4246 bfd_put_32 (output_bfd
, relocation
,
4247 htab
->elf
.sgot
->contents
+ off
);
4249 if (bfd_link_pic (info
))
4252 Elf_Internal_Rela outrel
;
4254 s
= htab
->elf
.srelgot
;
4258 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4259 + htab
->elf
.sgot
->output_offset
4261 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4262 elf_append_rel (output_bfd
, s
, &outrel
);
4265 local_got_offsets
[r_symndx
] |= 1;
4269 if (off
>= (bfd_vma
) -2)
4272 relocation
= (htab
->elf
.sgot
->output_section
->vma
4273 + htab
->elf
.sgot
->output_offset
+ off
);
4274 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4276 if (bfd_link_pic (info
))
4278 /* For PIC, disallow R_386_GOT32 without a base
4279 register since we don't know what the GOT base
4285 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4288 name
= h
->root
.root
.string
;
4291 /* xgettext:c-format */
4292 (_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
4293 input_bfd
, howto
->name
, name
);
4294 bfd_set_error (bfd_error_bad_value
);
4300 /* Subtract the .got.plt section address only with a base
4302 relocation
-= (htab
->elf
.sgotplt
->output_section
->vma
4303 + htab
->elf
.sgotplt
->output_offset
);
4309 /* Relocation is relative to the start of the global offset
4312 /* Check to make sure it isn't a protected function or data
4313 symbol for shared library since it may not be local when
4314 used as function address or with copy relocation. We also
4315 need to make sure that a symbol is referenced locally. */
4316 if (!bfd_link_executable (info
) && h
)
4318 if (!h
->def_regular
)
4322 switch (ELF_ST_VISIBILITY (h
->other
))
4325 v
= _("hidden symbol");
4328 v
= _("internal symbol");
4331 v
= _("protected symbol");
4339 /* xgettext:c-format */
4340 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4341 input_bfd
, v
, h
->root
.root
.string
);
4342 bfd_set_error (bfd_error_bad_value
);
4345 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4346 && (h
->type
== STT_FUNC
4347 || h
->type
== STT_OBJECT
)
4348 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4351 /* xgettext:c-format */
4352 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4354 h
->type
== STT_FUNC
? "function" : "data",
4355 h
->root
.root
.string
);
4356 bfd_set_error (bfd_error_bad_value
);
4361 /* Note that sgot is not involved in this
4362 calculation. We always want the start of .got.plt. If we
4363 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4364 permitted by the ABI, we might have to change this
4366 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4367 + htab
->elf
.sgotplt
->output_offset
;
4371 /* Use global offset table as symbol value. */
4372 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4373 + htab
->elf
.sgotplt
->output_offset
;
4374 unresolved_reloc
= FALSE
;
4378 /* Relocation is to the entry for this symbol in the
4379 procedure linkage table. */
4381 /* Resolve a PLT32 reloc against a local symbol directly,
4382 without using the procedure linkage table. */
4386 if ((h
->plt
.offset
== (bfd_vma
) -1
4387 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4388 || htab
->elf
.splt
== NULL
)
4390 /* We didn't make a PLT entry for this symbol. This
4391 happens when statically linking PIC code, or when
4392 using -Bsymbolic. */
4396 if (h
->plt
.offset
!= (bfd_vma
) -1)
4398 resolved_plt
= htab
->elf
.splt
;
4399 plt_offset
= h
->plt
.offset
;
4403 resolved_plt
= htab
->plt_got
;
4404 plt_offset
= eh
->plt_got
.offset
;
4407 relocation
= (resolved_plt
->output_section
->vma
4408 + resolved_plt
->output_offset
4410 unresolved_reloc
= FALSE
;
4414 /* Set to symbol size. */
4415 relocation
= st_size
;
4420 if ((input_section
->flags
& SEC_ALLOC
) == 0
4424 /* Copy dynamic function pointer relocations. Don't generate
4425 dynamic relocations against resolved undefined weak symbols
4426 in PIE, except for R_386_PC32. */
4427 if ((bfd_link_pic (info
)
4429 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4430 && (!resolved_to_zero
4431 || r_type
== R_386_PC32
))
4432 || h
->root
.type
!= bfd_link_hash_undefweak
))
4433 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4434 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4435 || (ELIMINATE_COPY_RELOCS
4436 && !bfd_link_pic (info
)
4440 || eh
->func_pointer_refcount
> 0
4441 || (h
->root
.type
== bfd_link_hash_undefweak
4442 && !resolved_to_zero
))
4443 && ((h
->def_dynamic
&& !h
->def_regular
)
4444 /* Undefined weak symbol is bound locally when
4446 || h
->root
.type
== bfd_link_hash_undefweak
)))
4448 Elf_Internal_Rela outrel
;
4449 bfd_boolean skip
, relocate
;
4452 /* When generating a shared object, these relocations
4453 are copied into the output file to be resolved at run
4460 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4462 if (outrel
.r_offset
== (bfd_vma
) -1)
4464 else if (outrel
.r_offset
== (bfd_vma
) -2)
4465 skip
= TRUE
, relocate
= TRUE
;
4466 outrel
.r_offset
+= (input_section
->output_section
->vma
4467 + input_section
->output_offset
);
4470 memset (&outrel
, 0, sizeof outrel
);
4473 && (r_type
== R_386_PC32
4474 || !(bfd_link_executable (info
)
4475 || SYMBOLIC_BIND (info
, h
))
4476 || !h
->def_regular
))
4477 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4480 /* This symbol is local, or marked to become local. */
4482 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4485 sreloc
= elf_section_data (input_section
)->sreloc
;
4487 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4489 r
= bfd_reloc_notsupported
;
4490 goto check_relocation_error
;
4493 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4495 /* If this reloc is against an external symbol, we do
4496 not want to fiddle with the addend. Otherwise, we
4497 need to include the symbol value so that it becomes
4498 an addend for the dynamic reloc. */
4505 if (!bfd_link_executable (info
))
4507 Elf_Internal_Rela outrel
;
4510 outrel
.r_offset
= rel
->r_offset
4511 + input_section
->output_section
->vma
4512 + input_section
->output_offset
;
4513 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4514 sreloc
= elf_section_data (input_section
)->sreloc
;
4517 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4522 case R_386_TLS_GOTDESC
:
4523 case R_386_TLS_DESC_CALL
:
4524 case R_386_TLS_IE_32
:
4525 case R_386_TLS_GOTIE
:
4526 tls_type
= GOT_UNKNOWN
;
4527 if (h
== NULL
&& local_got_offsets
)
4528 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4530 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4531 if (tls_type
== GOT_TLS_IE
)
4532 tls_type
= GOT_TLS_IE_NEG
;
4534 if (! elf_i386_tls_transition (info
, input_bfd
,
4535 input_section
, contents
,
4536 symtab_hdr
, sym_hashes
,
4537 &r_type
, tls_type
, rel
,
4538 relend
, h
, r_symndx
, TRUE
))
4541 if (r_type
== R_386_TLS_LE_32
)
4543 BFD_ASSERT (! unresolved_reloc
);
4544 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4549 /* GD->LE transition. */
4550 type
= *(contents
+ rel
->r_offset
- 2);
4554 leal foo@tlsgd(,%ebx,1), %eax
4555 call ___tls_get_addr@PLT
4558 subl $foo@tpoff, %eax
4559 (6 byte form of subl). */
4560 roff
= rel
->r_offset
+ 5;
4565 leal foo@tlsgd(%ebx), %eax
4566 call ___tls_get_addr@PLT
4569 leal foo@tlsgd(%reg), %eax
4570 call *___tls_get_addr@GOT(%reg)
4571 which may be converted to
4572 addr32 call ___tls_get_addr
4574 movl %gs:0, %eax; subl $foo@tpoff, %eax
4575 (6 byte form of subl). */
4576 roff
= rel
->r_offset
+ 6;
4578 memcpy (contents
+ roff
- 8,
4579 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4580 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4582 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4587 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4589 /* GDesc -> LE transition.
4590 It's originally something like:
4591 leal x@tlsdesc(%ebx), %eax
4595 Registers other than %eax may be set up here. */
4600 roff
= rel
->r_offset
;
4601 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4603 /* Now modify the instruction as appropriate. */
4604 /* aoliva FIXME: remove the above and xor the byte
4606 bfd_put_8 (output_bfd
, val
^ 0x86,
4607 contents
+ roff
- 1);
4608 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4612 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4614 /* GDesc -> LE transition.
4622 roff
= rel
->r_offset
;
4623 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4624 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4627 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4631 /* IE->LE transition:
4632 Originally it can be one of:
4640 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4643 /* movl foo, %eax. */
4644 bfd_put_8 (output_bfd
, 0xb8,
4645 contents
+ rel
->r_offset
- 1);
4651 type
= bfd_get_8 (input_bfd
,
4652 contents
+ rel
->r_offset
- 2);
4657 bfd_put_8 (output_bfd
, 0xc7,
4658 contents
+ rel
->r_offset
- 2);
4659 bfd_put_8 (output_bfd
,
4660 0xc0 | ((val
>> 3) & 7),
4661 contents
+ rel
->r_offset
- 1);
4665 bfd_put_8 (output_bfd
, 0x81,
4666 contents
+ rel
->r_offset
- 2);
4667 bfd_put_8 (output_bfd
,
4668 0xc0 | ((val
>> 3) & 7),
4669 contents
+ rel
->r_offset
- 1);
4676 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4677 contents
+ rel
->r_offset
);
4682 unsigned int val
, type
;
4684 /* {IE_32,GOTIE}->LE transition:
4685 Originally it can be one of:
4686 subl foo(%reg1), %reg2
4687 movl foo(%reg1), %reg2
4688 addl foo(%reg1), %reg2
4691 movl $foo, %reg2 (6 byte form)
4692 addl $foo, %reg2. */
4693 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4694 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4698 bfd_put_8 (output_bfd
, 0xc7,
4699 contents
+ rel
->r_offset
- 2);
4700 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4701 contents
+ rel
->r_offset
- 1);
4703 else if (type
== 0x2b)
4706 bfd_put_8 (output_bfd
, 0x81,
4707 contents
+ rel
->r_offset
- 2);
4708 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4709 contents
+ rel
->r_offset
- 1);
4711 else if (type
== 0x03)
4714 bfd_put_8 (output_bfd
, 0x81,
4715 contents
+ rel
->r_offset
- 2);
4716 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4717 contents
+ rel
->r_offset
- 1);
4721 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4722 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4723 contents
+ rel
->r_offset
);
4725 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4726 contents
+ rel
->r_offset
);
4731 if (htab
->elf
.sgot
== NULL
)
4736 off
= h
->got
.offset
;
4737 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4741 if (local_got_offsets
== NULL
)
4744 off
= local_got_offsets
[r_symndx
];
4745 offplt
= local_tlsdesc_gotents
[r_symndx
];
4752 Elf_Internal_Rela outrel
;
4756 if (htab
->elf
.srelgot
== NULL
)
4759 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4761 if (GOT_TLS_GDESC_P (tls_type
))
4764 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4765 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4766 <= htab
->elf
.sgotplt
->size
);
4767 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4768 + htab
->elf
.sgotplt
->output_offset
4770 + htab
->sgotplt_jump_table_size
);
4771 sreloc
= htab
->elf
.srelplt
;
4772 loc
= sreloc
->contents
;
4773 loc
+= (htab
->next_tls_desc_index
++
4774 * sizeof (Elf32_External_Rel
));
4775 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4776 <= sreloc
->contents
+ sreloc
->size
);
4777 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4780 BFD_ASSERT (! unresolved_reloc
);
4781 bfd_put_32 (output_bfd
,
4782 relocation
- elf_i386_dtpoff_base (info
),
4783 htab
->elf
.sgotplt
->contents
+ offplt
4784 + htab
->sgotplt_jump_table_size
+ 4);
4788 bfd_put_32 (output_bfd
, 0,
4789 htab
->elf
.sgotplt
->contents
+ offplt
4790 + htab
->sgotplt_jump_table_size
+ 4);
4794 sreloc
= htab
->elf
.srelgot
;
4796 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4797 + htab
->elf
.sgot
->output_offset
+ off
);
4799 if (GOT_TLS_GD_P (tls_type
))
4800 dr_type
= R_386_TLS_DTPMOD32
;
4801 else if (GOT_TLS_GDESC_P (tls_type
))
4803 else if (tls_type
== GOT_TLS_IE_POS
)
4804 dr_type
= R_386_TLS_TPOFF
;
4806 dr_type
= R_386_TLS_TPOFF32
;
4808 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4809 bfd_put_32 (output_bfd
,
4810 relocation
- elf_i386_dtpoff_base (info
),
4811 htab
->elf
.sgot
->contents
+ off
);
4812 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4813 bfd_put_32 (output_bfd
,
4814 elf_i386_dtpoff_base (info
) - relocation
,
4815 htab
->elf
.sgot
->contents
+ off
);
4816 else if (dr_type
!= R_386_TLS_DESC
)
4817 bfd_put_32 (output_bfd
, 0,
4818 htab
->elf
.sgot
->contents
+ off
);
4819 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4821 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4823 if (GOT_TLS_GD_P (tls_type
))
4827 BFD_ASSERT (! unresolved_reloc
);
4828 bfd_put_32 (output_bfd
,
4829 relocation
- elf_i386_dtpoff_base (info
),
4830 htab
->elf
.sgot
->contents
+ off
+ 4);
4834 bfd_put_32 (output_bfd
, 0,
4835 htab
->elf
.sgot
->contents
+ off
+ 4);
4836 outrel
.r_info
= ELF32_R_INFO (indx
,
4837 R_386_TLS_DTPOFF32
);
4838 outrel
.r_offset
+= 4;
4839 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4842 else if (tls_type
== GOT_TLS_IE_BOTH
)
4844 bfd_put_32 (output_bfd
,
4846 ? relocation
- elf_i386_dtpoff_base (info
)
4848 htab
->elf
.sgot
->contents
+ off
+ 4);
4849 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4850 outrel
.r_offset
+= 4;
4851 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4858 local_got_offsets
[r_symndx
] |= 1;
4861 if (off
>= (bfd_vma
) -2
4862 && ! GOT_TLS_GDESC_P (tls_type
))
4864 if (r_type
== R_386_TLS_GOTDESC
4865 || r_type
== R_386_TLS_DESC_CALL
)
4867 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4868 unresolved_reloc
= FALSE
;
4870 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4872 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4873 + htab
->elf
.sgotplt
->output_offset
;
4874 relocation
= htab
->elf
.sgot
->output_section
->vma
4875 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4876 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4877 && tls_type
== GOT_TLS_IE_BOTH
)
4879 if (r_type
== R_386_TLS_IE
)
4880 relocation
+= g_o_t
;
4881 unresolved_reloc
= FALSE
;
4883 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4885 unsigned int val
, type
;
4888 /* GD->IE transition. */
4889 type
= *(contents
+ rel
->r_offset
- 2);
4890 val
= *(contents
+ rel
->r_offset
- 1);
4894 leal foo@tlsgd(,%ebx,1), %eax
4895 call ___tls_get_addr@PLT
4898 subl $foo@gottpoff(%ebx), %eax. */
4900 roff
= rel
->r_offset
- 3;
4905 leal foo@tlsgd(%ebx), %eax
4906 call ___tls_get_addr@PLT
4909 leal foo@tlsgd(%reg), %eax
4910 call *___tls_get_addr@GOT(%reg)
4911 which may be converted to
4912 addr32 call ___tls_get_addr
4915 subl $foo@gottpoff(%reg), %eax. */
4916 roff
= rel
->r_offset
- 2;
4918 memcpy (contents
+ roff
,
4919 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4920 contents
[roff
+ 7] = 0x80 | (val
& 7);
4921 /* If foo is used only with foo@gotntpoff(%reg) and
4922 foo@indntpoff, but not with foo@gottpoff(%reg), change
4923 subl $foo@gottpoff(%reg), %eax
4925 addl $foo@gotntpoff(%reg), %eax. */
4926 if (tls_type
== GOT_TLS_IE_POS
)
4927 contents
[roff
+ 6] = 0x03;
4928 bfd_put_32 (output_bfd
,
4929 htab
->elf
.sgot
->output_section
->vma
4930 + htab
->elf
.sgot
->output_offset
+ off
4931 - htab
->elf
.sgotplt
->output_section
->vma
4932 - htab
->elf
.sgotplt
->output_offset
,
4933 contents
+ roff
+ 8);
4934 /* Skip R_386_PLT32 and R_386_GOT32X. */
4939 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4941 /* GDesc -> IE transition.
4942 It's originally something like:
4943 leal x@tlsdesc(%ebx), %eax
4946 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4948 movl x@gottpoff(%ebx), %eax # before negl %eax
4950 Registers other than %eax may be set up here. */
4954 /* First, make sure it's a leal adding ebx to a 32-bit
4955 offset into any register, although it's probably
4956 almost always going to be eax. */
4957 roff
= rel
->r_offset
;
4959 /* Now modify the instruction as appropriate. */
4960 /* To turn a leal into a movl in the form we use it, it
4961 suffices to change the first byte from 0x8d to 0x8b.
4962 aoliva FIXME: should we decide to keep the leal, all
4963 we have to do is remove the statement below, and
4964 adjust the relaxation of R_386_TLS_DESC_CALL. */
4965 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4967 if (tls_type
== GOT_TLS_IE_BOTH
)
4970 bfd_put_32 (output_bfd
,
4971 htab
->elf
.sgot
->output_section
->vma
4972 + htab
->elf
.sgot
->output_offset
+ off
4973 - htab
->elf
.sgotplt
->output_section
->vma
4974 - htab
->elf
.sgotplt
->output_offset
,
4978 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4980 /* GDesc -> IE transition.
4988 depending on how we transformed the TLS_GOTDESC above.
4993 roff
= rel
->r_offset
;
4995 /* Now modify the instruction as appropriate. */
4996 if (tls_type
!= GOT_TLS_IE_NEG
)
4999 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5000 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5005 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
5006 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
5016 if (! elf_i386_tls_transition (info
, input_bfd
,
5017 input_section
, contents
,
5018 symtab_hdr
, sym_hashes
,
5019 &r_type
, GOT_UNKNOWN
, rel
,
5020 relend
, h
, r_symndx
, TRUE
))
5023 if (r_type
!= R_386_TLS_LDM
)
5025 /* LD->LE transition. Change
5026 leal foo@tlsldm(%ebx) %eax
5027 call ___tls_get_addr@PLT
5031 leal 0(%esi,1), %esi
5033 leal foo@tlsldm(%reg) %eax
5034 call *___tls_get_addr@GOT(%reg)
5035 which may be converted to
5036 addr32 call ___tls_get_addr
5039 leal 0(%esi), %esi */
5040 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
5041 if (*(contents
+ rel
->r_offset
+ 4) == 0xff
5042 || *(contents
+ rel
->r_offset
+ 4) == 0x67)
5043 memcpy (contents
+ rel
->r_offset
- 2,
5044 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5046 memcpy (contents
+ rel
->r_offset
- 2,
5047 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5048 /* Skip R_386_PC32/R_386_PLT32. */
5054 if (htab
->elf
.sgot
== NULL
)
5057 off
= htab
->tls_ldm_got
.offset
;
5062 Elf_Internal_Rela outrel
;
5064 if (htab
->elf
.srelgot
== NULL
)
5067 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5068 + htab
->elf
.sgot
->output_offset
+ off
);
5070 bfd_put_32 (output_bfd
, 0,
5071 htab
->elf
.sgot
->contents
+ off
);
5072 bfd_put_32 (output_bfd
, 0,
5073 htab
->elf
.sgot
->contents
+ off
+ 4);
5074 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
5075 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
5076 htab
->tls_ldm_got
.offset
|= 1;
5078 relocation
= htab
->elf
.sgot
->output_section
->vma
5079 + htab
->elf
.sgot
->output_offset
+ off
5080 - htab
->elf
.sgotplt
->output_section
->vma
5081 - htab
->elf
.sgotplt
->output_offset
;
5082 unresolved_reloc
= FALSE
;
5085 case R_386_TLS_LDO_32
:
5086 if (!bfd_link_executable (info
)
5087 || (input_section
->flags
& SEC_CODE
) == 0)
5088 relocation
-= elf_i386_dtpoff_base (info
);
5090 /* When converting LDO to LE, we must negate. */
5091 relocation
= -elf_i386_tpoff (info
, relocation
);
5094 case R_386_TLS_LE_32
:
5096 if (!bfd_link_executable (info
))
5098 Elf_Internal_Rela outrel
;
5101 outrel
.r_offset
= rel
->r_offset
5102 + input_section
->output_section
->vma
5103 + input_section
->output_offset
;
5104 if (h
!= NULL
&& h
->dynindx
!= -1)
5108 if (r_type
== R_386_TLS_LE_32
)
5109 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
5111 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
5112 sreloc
= elf_section_data (input_section
)->sreloc
;
5115 elf_append_rel (output_bfd
, sreloc
, &outrel
);
5118 else if (r_type
== R_386_TLS_LE_32
)
5119 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
5121 relocation
-= elf_i386_dtpoff_base (info
);
5123 else if (r_type
== R_386_TLS_LE_32
)
5124 relocation
= elf_i386_tpoff (info
, relocation
);
5126 relocation
= -elf_i386_tpoff (info
, relocation
);
5133 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5134 because such sections are not SEC_ALLOC and thus ld.so will
5135 not process them. */
5136 if (unresolved_reloc
5137 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5139 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5140 rel
->r_offset
) != (bfd_vma
) -1)
5143 /* xgettext:c-format */
5144 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5147 (long) rel
->r_offset
,
5149 h
->root
.root
.string
);
5154 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5155 contents
, rel
->r_offset
,
5158 check_relocation_error
:
5159 if (r
!= bfd_reloc_ok
)
5164 name
= h
->root
.root
.string
;
5167 name
= bfd_elf_string_from_elf_section (input_bfd
,
5168 symtab_hdr
->sh_link
,
5173 name
= bfd_section_name (input_bfd
, sec
);
5176 if (r
== bfd_reloc_overflow
)
5177 (*info
->callbacks
->reloc_overflow
)
5178 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5179 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5183 /* xgettext:c-format */
5184 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5185 input_bfd
, input_section
,
5186 (long) rel
->r_offset
, name
, (int) r
);
5197 Elf_Internal_Shdr
*rel_hdr
;
5198 size_t deleted
= rel
- wrel
;
5200 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5201 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5202 if (rel_hdr
->sh_size
== 0)
5204 /* It is too late to remove an empty reloc section. Leave
5206 ??? What is wrong with an empty section??? */
5207 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5210 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5211 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5212 input_section
->reloc_count
-= deleted
;
5218 /* Finish up dynamic symbol handling. We set the contents of various
5219 dynamic sections here. */
5222 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5223 struct bfd_link_info
*info
,
5224 struct elf_link_hash_entry
*h
,
5225 Elf_Internal_Sym
*sym
)
5227 struct elf_i386_link_hash_table
*htab
;
5228 unsigned plt_entry_size
;
5229 const struct elf_i386_backend_data
*abed
;
5230 struct elf_i386_link_hash_entry
*eh
;
5231 bfd_boolean local_undefweak
;
5233 htab
= elf_i386_hash_table (info
);
5237 abed
= get_elf_i386_backend_data (output_bfd
);
5238 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5240 eh
= (struct elf_i386_link_hash_entry
*) h
;
5242 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5243 resolved undefined weak symbols in executable so that their
5244 references have value 0 at run-time. */
5245 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5249 if (h
->plt
.offset
!= (bfd_vma
) -1)
5253 Elf_Internal_Rela rel
;
5255 asection
*plt
, *gotplt
, *relplt
;
5257 /* When building a static executable, use .iplt, .igot.plt and
5258 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5259 if (htab
->elf
.splt
!= NULL
)
5261 plt
= htab
->elf
.splt
;
5262 gotplt
= htab
->elf
.sgotplt
;
5263 relplt
= htab
->elf
.srelplt
;
5267 plt
= htab
->elf
.iplt
;
5268 gotplt
= htab
->elf
.igotplt
;
5269 relplt
= htab
->elf
.irelplt
;
5272 /* This symbol has an entry in the procedure linkage table. Set
5275 if ((h
->dynindx
== -1
5277 && !((h
->forced_local
|| bfd_link_executable (info
))
5279 && h
->type
== STT_GNU_IFUNC
))
5285 /* Get the index in the procedure linkage table which
5286 corresponds to this symbol. This is the index of this symbol
5287 in all the symbols for which we are making plt entries. The
5288 first entry in the procedure linkage table is reserved.
5290 Get the offset into the .got table of the entry that
5291 corresponds to this function. Each .got entry is 4 bytes.
5292 The first three are reserved.
5294 For static executables, we don't reserve anything. */
5296 if (plt
== htab
->elf
.splt
)
5298 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5299 got_offset
= (got_offset
+ 3) * 4;
5303 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5304 got_offset
= got_offset
* 4;
5307 /* Fill in the entry in the procedure linkage table. */
5308 if (! bfd_link_pic (info
))
5310 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5311 abed
->plt
->plt_entry_size
);
5312 bfd_put_32 (output_bfd
,
5313 (gotplt
->output_section
->vma
5314 + gotplt
->output_offset
5316 plt
->contents
+ h
->plt
.offset
5317 + abed
->plt
->plt_got_offset
);
5319 if (abed
->is_vxworks
)
5321 int s
, k
, reloc_index
;
5323 /* Create the R_386_32 relocation referencing the GOT
5324 for this PLT entry. */
5326 /* S: Current slot number (zero-based). */
5327 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5328 / abed
->plt
->plt_entry_size
);
5329 /* K: Number of relocations for PLTResolve. */
5330 if (bfd_link_pic (info
))
5331 k
= PLTRESOLVE_RELOCS_SHLIB
;
5333 k
= PLTRESOLVE_RELOCS
;
5334 /* Skip the PLTresolve relocations, and the relocations for
5335 the other PLT slots. */
5336 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5337 loc
= (htab
->srelplt2
->contents
+ reloc_index
5338 * sizeof (Elf32_External_Rel
));
5340 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5341 + htab
->elf
.splt
->output_offset
5342 + h
->plt
.offset
+ 2),
5343 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5344 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5346 /* Create the R_386_32 relocation referencing the beginning of
5347 the PLT for this GOT entry. */
5348 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5349 + htab
->elf
.sgotplt
->output_offset
5351 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5352 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5353 loc
+ sizeof (Elf32_External_Rel
));
5358 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5359 abed
->plt
->plt_entry_size
);
5360 bfd_put_32 (output_bfd
, got_offset
,
5361 plt
->contents
+ h
->plt
.offset
5362 + abed
->plt
->plt_got_offset
);
5365 /* Fill in the entry in the global offset table. Leave the entry
5366 as zero for undefined weak symbol in PIE. No PLT relocation
5367 against undefined weak symbol in PIE. */
5368 if (!local_undefweak
)
5370 bfd_put_32 (output_bfd
,
5371 (plt
->output_section
->vma
5372 + plt
->output_offset
5374 + abed
->plt
->plt_lazy_offset
),
5375 gotplt
->contents
+ got_offset
);
5377 /* Fill in the entry in the .rel.plt section. */
5378 rel
.r_offset
= (gotplt
->output_section
->vma
5379 + gotplt
->output_offset
5381 if (h
->dynindx
== -1
5382 || ((bfd_link_executable (info
)
5383 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5385 && h
->type
== STT_GNU_IFUNC
))
5387 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5388 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5389 in the .got.plt section. */
5390 bfd_put_32 (output_bfd
,
5391 (h
->root
.u
.def
.value
5392 + h
->root
.u
.def
.section
->output_section
->vma
5393 + h
->root
.u
.def
.section
->output_offset
),
5394 gotplt
->contents
+ got_offset
);
5395 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5396 /* R_386_IRELATIVE comes last. */
5397 plt_index
= htab
->next_irelative_index
--;
5401 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5402 plt_index
= htab
->next_jump_slot_index
++;
5405 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5406 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5408 /* Don't fill PLT entry for static executables. */
5409 if (plt
== htab
->elf
.splt
)
5411 bfd_put_32 (output_bfd
,
5412 plt_index
* sizeof (Elf32_External_Rel
),
5413 plt
->contents
+ h
->plt
.offset
5414 + abed
->plt
->plt_reloc_offset
);
5415 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5416 + abed
->plt
->plt_plt_offset
+ 4),
5417 plt
->contents
+ h
->plt
.offset
5418 + abed
->plt
->plt_plt_offset
);
5422 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5424 bfd_vma got_offset
, plt_offset
;
5425 asection
*plt
, *got
, *gotplt
;
5426 const bfd_byte
*got_plt_entry
;
5428 /* Offset of displacement of the indirect jump. */
5429 bfd_vma plt_got_offset
= 2;
5431 /* Set the entry in the GOT procedure linkage table. */
5432 plt
= htab
->plt_got
;
5433 got
= htab
->elf
.sgot
;
5434 gotplt
= htab
->elf
.sgotplt
;
5435 got_offset
= h
->got
.offset
;
5437 if (got_offset
== (bfd_vma
) -1
5443 /* Fill in the entry in the GOT procedure linkage table. */
5444 if (! bfd_link_pic (info
))
5446 got_plt_entry
= elf_i386_got_plt_entry
;
5447 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5451 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5452 got_offset
+= (got
->output_section
->vma
5453 + got
->output_offset
5454 - gotplt
->output_section
->vma
5455 - gotplt
->output_offset
);
5458 plt_offset
= eh
->plt_got
.offset
;
5459 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5460 sizeof (elf_i386_got_plt_entry
));
5461 bfd_put_32 (output_bfd
, got_offset
,
5462 plt
->contents
+ plt_offset
+ plt_got_offset
);
5465 if (!local_undefweak
5467 && (h
->plt
.offset
!= (bfd_vma
) -1
5468 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5470 /* Mark the symbol as undefined, rather than as defined in
5471 the .plt section. Leave the value if there were any
5472 relocations where pointer equality matters (this is a clue
5473 for the dynamic linker, to make function pointer
5474 comparisons work between an application and shared
5475 library), otherwise set it to zero. If a function is only
5476 called from a binary, there is no need to slow down
5477 shared libraries because of that. */
5478 sym
->st_shndx
= SHN_UNDEF
;
5479 if (!h
->pointer_equality_needed
)
5483 /* Don't generate dynamic GOT relocation against undefined weak
5484 symbol in executable. */
5485 if (h
->got
.offset
!= (bfd_vma
) -1
5486 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5487 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5488 && !local_undefweak
)
5490 Elf_Internal_Rela rel
;
5491 asection
*relgot
= htab
->elf
.srelgot
;
5493 /* This symbol has an entry in the global offset table. Set it
5496 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5499 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5500 + htab
->elf
.sgot
->output_offset
5501 + (h
->got
.offset
& ~(bfd_vma
) 1));
5503 /* If this is a static link, or it is a -Bsymbolic link and the
5504 symbol is defined locally or was forced to be local because
5505 of a version file, we just want to emit a RELATIVE reloc.
5506 The entry in the global offset table will already have been
5507 initialized in the relocate_section function. */
5509 && h
->type
== STT_GNU_IFUNC
)
5511 if (h
->plt
.offset
== (bfd_vma
) -1)
5513 /* STT_GNU_IFUNC is referenced without PLT. */
5514 if (htab
->elf
.splt
== NULL
)
5516 /* use .rel[a].iplt section to store .got relocations
5517 in static executable. */
5518 relgot
= htab
->elf
.irelplt
;
5520 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5522 bfd_put_32 (output_bfd
,
5523 (h
->root
.u
.def
.value
5524 + h
->root
.u
.def
.section
->output_section
->vma
5525 + h
->root
.u
.def
.section
->output_offset
),
5526 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5527 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5532 else if (bfd_link_pic (info
))
5534 /* Generate R_386_GLOB_DAT. */
5541 if (!h
->pointer_equality_needed
)
5544 /* For non-shared object, we can't use .got.plt, which
5545 contains the real function addres if we need pointer
5546 equality. We load the GOT entry with the PLT entry. */
5547 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5548 bfd_put_32 (output_bfd
,
5549 (plt
->output_section
->vma
5550 + plt
->output_offset
+ h
->plt
.offset
),
5551 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5555 else if (bfd_link_pic (info
)
5556 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5558 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5559 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5563 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5565 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5566 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5567 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5570 elf_append_rel (output_bfd
, relgot
, &rel
);
5575 Elf_Internal_Rela rel
;
5578 /* This symbol needs a copy reloc. Set it up. */
5580 if (h
->dynindx
== -1
5581 || (h
->root
.type
!= bfd_link_hash_defined
5582 && h
->root
.type
!= bfd_link_hash_defweak
)
5583 || htab
->elf
.srelbss
== NULL
5584 || htab
->elf
.sreldynrelro
== NULL
)
5587 rel
.r_offset
= (h
->root
.u
.def
.value
5588 + h
->root
.u
.def
.section
->output_section
->vma
5589 + h
->root
.u
.def
.section
->output_offset
);
5590 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5591 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
5592 s
= htab
->elf
.sreldynrelro
;
5594 s
= htab
->elf
.srelbss
;
5595 elf_append_rel (output_bfd
, s
, &rel
);
5601 /* Finish up local dynamic symbol handling. We set the contents of
5602 various dynamic sections here. */
5605 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5607 struct elf_link_hash_entry
*h
5608 = (struct elf_link_hash_entry
*) *slot
;
5609 struct bfd_link_info
*info
5610 = (struct bfd_link_info
*) inf
;
5612 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5616 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5617 here since undefined weak symbol may not be dynamic and may not be
5618 called for elf_i386_finish_dynamic_symbol. */
5621 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5624 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5625 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5627 if (h
->root
.type
!= bfd_link_hash_undefweak
5628 || h
->dynindx
!= -1)
5631 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5635 /* Used to decide how to sort relocs in an optimal manner for the
5636 dynamic linker, before writing them out. */
5638 static enum elf_reloc_type_class
5639 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5640 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5641 const Elf_Internal_Rela
*rela
)
5643 bfd
*abfd
= info
->output_bfd
;
5644 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5645 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5647 if (htab
->dynsym
!= NULL
5648 && htab
->dynsym
->contents
!= NULL
)
5650 /* Check relocation against STT_GNU_IFUNC symbol if there are
5652 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5653 if (r_symndx
!= STN_UNDEF
)
5655 Elf_Internal_Sym sym
;
5656 if (!bed
->s
->swap_symbol_in (abfd
,
5657 (htab
->dynsym
->contents
5658 + r_symndx
* sizeof (Elf32_External_Sym
)),
5662 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5663 return reloc_class_ifunc
;
5667 switch (ELF32_R_TYPE (rela
->r_info
))
5669 case R_386_IRELATIVE
:
5670 return reloc_class_ifunc
;
5671 case R_386_RELATIVE
:
5672 return reloc_class_relative
;
5673 case R_386_JUMP_SLOT
:
5674 return reloc_class_plt
;
5676 return reloc_class_copy
;
5678 return reloc_class_normal
;
5682 /* Finish up the dynamic sections. */
5685 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5686 struct bfd_link_info
*info
)
5688 struct elf_i386_link_hash_table
*htab
;
5691 const struct elf_i386_backend_data
*abed
;
5693 htab
= elf_i386_hash_table (info
);
5697 dynobj
= htab
->elf
.dynobj
;
5698 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5699 abed
= get_elf_i386_backend_data (output_bfd
);
5701 if (htab
->elf
.dynamic_sections_created
)
5703 Elf32_External_Dyn
*dyncon
, *dynconend
;
5705 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5708 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5709 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5710 for (; dyncon
< dynconend
; dyncon
++)
5712 Elf_Internal_Dyn dyn
;
5715 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5720 if (abed
->is_vxworks
5721 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5726 s
= htab
->elf
.sgotplt
;
5727 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5731 s
= htab
->elf
.srelplt
;
5732 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5736 s
= htab
->elf
.srelplt
;
5737 dyn
.d_un
.d_val
= s
->size
;
5741 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5744 /* Fill in the first entry in the procedure linkage table. */
5745 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5747 if (bfd_link_pic (info
))
5749 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5750 abed
->plt
->plt0_entry_size
);
5751 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5752 abed
->plt0_pad_byte
,
5753 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5757 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5758 abed
->plt
->plt0_entry_size
);
5759 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5760 abed
->plt0_pad_byte
,
5761 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5762 bfd_put_32 (output_bfd
,
5763 (htab
->elf
.sgotplt
->output_section
->vma
5764 + htab
->elf
.sgotplt
->output_offset
5766 htab
->elf
.splt
->contents
5767 + abed
->plt
->plt0_got1_offset
);
5768 bfd_put_32 (output_bfd
,
5769 (htab
->elf
.sgotplt
->output_section
->vma
5770 + htab
->elf
.sgotplt
->output_offset
5772 htab
->elf
.splt
->contents
5773 + abed
->plt
->plt0_got2_offset
);
5775 if (abed
->is_vxworks
)
5777 Elf_Internal_Rela rel
;
5779 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5780 On IA32 we use REL relocations so the addend goes in
5781 the PLT directly. */
5782 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5783 + htab
->elf
.splt
->output_offset
5784 + abed
->plt
->plt0_got1_offset
);
5785 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5786 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5787 htab
->srelplt2
->contents
);
5788 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5789 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5790 + htab
->elf
.splt
->output_offset
5791 + abed
->plt
->plt0_got2_offset
);
5792 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5793 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5794 htab
->srelplt2
->contents
+
5795 sizeof (Elf32_External_Rel
));
5799 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5800 really seem like the right value. */
5801 elf_section_data (htab
->elf
.splt
->output_section
)
5802 ->this_hdr
.sh_entsize
= 4;
5804 /* Correct the .rel.plt.unloaded relocations. */
5805 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5807 int num_plts
= (htab
->elf
.splt
->size
5808 / abed
->plt
->plt_entry_size
) - 1;
5811 p
= htab
->srelplt2
->contents
;
5812 if (bfd_link_pic (info
))
5813 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5815 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5817 for (; num_plts
; num_plts
--)
5819 Elf_Internal_Rela rel
;
5820 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5821 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5822 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5823 p
+= sizeof (Elf32_External_Rel
);
5825 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5826 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5827 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5828 p
+= sizeof (Elf32_External_Rel
);
5834 if (htab
->elf
.sgotplt
)
5836 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5839 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5843 /* Fill in the first three entries in the global offset table. */
5844 if (htab
->elf
.sgotplt
->size
> 0)
5846 bfd_put_32 (output_bfd
,
5848 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5849 htab
->elf
.sgotplt
->contents
);
5850 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5851 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5854 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5857 /* Adjust .eh_frame for .plt section. */
5858 if (htab
->plt_eh_frame
!= NULL
5859 && htab
->plt_eh_frame
->contents
!= NULL
)
5861 if (htab
->elf
.splt
!= NULL
5862 && htab
->elf
.splt
->size
!= 0
5863 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5864 && htab
->elf
.splt
->output_section
!= NULL
5865 && htab
->plt_eh_frame
->output_section
!= NULL
)
5867 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5868 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5869 + htab
->plt_eh_frame
->output_offset
5870 + PLT_FDE_START_OFFSET
;
5871 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5872 htab
->plt_eh_frame
->contents
5873 + PLT_FDE_START_OFFSET
);
5875 if (htab
->plt_eh_frame
->sec_info_type
5876 == SEC_INFO_TYPE_EH_FRAME
)
5878 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5880 htab
->plt_eh_frame
->contents
))
5885 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5886 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5888 /* Fill PLT entries for undefined weak symbols in PIE. */
5889 if (bfd_link_pie (info
))
5890 bfd_hash_traverse (&info
->hash
->table
,
5891 elf_i386_pie_finish_undefweak_symbol
,
5897 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5898 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5899 It has to be done before elf_link_sort_relocs is called so that
5900 dynamic relocations are properly sorted. */
5903 elf_i386_output_arch_local_syms
5904 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5905 struct bfd_link_info
*info
,
5906 void *flaginfo ATTRIBUTE_UNUSED
,
5907 int (*func
) (void *, const char *,
5910 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5912 struct elf_i386_link_hash_table
*htab
= elf_i386_hash_table (info
);
5916 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5917 htab_traverse (htab
->loc_hash_table
,
5918 elf_i386_finish_local_dynamic_symbol
,
5924 /* Return an array of PLT entry symbol values. */
5927 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5930 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5933 bfd_vma
*plt_sym_val
;
5935 bfd_byte
*plt_contents
;
5936 const struct elf_i386_backend_data
*bed
5937 = get_elf_i386_backend_data (abfd
);
5938 Elf_Internal_Shdr
*hdr
;
5940 /* Get the .plt section contents. */
5941 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5942 if (plt_contents
== NULL
)
5944 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5945 plt_contents
, 0, plt
->size
))
5948 free (plt_contents
);
5952 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5953 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5956 hdr
= &elf_section_data (relplt
)->this_hdr
;
5957 count
= relplt
->size
/ hdr
->sh_entsize
;
5959 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5960 if (plt_sym_val
== NULL
)
5963 for (i
= 0; i
< count
; i
++)
5964 plt_sym_val
[i
] = -1;
5966 plt_offset
= bed
->plt
->plt_entry_size
;
5967 p
= relplt
->relocation
;
5968 for (i
= 0; i
< count
; i
++, p
++)
5972 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5973 if (p
->howto
== NULL
)
5976 if (p
->howto
->type
!= R_386_JUMP_SLOT
5977 && p
->howto
->type
!= R_386_IRELATIVE
)
5980 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5981 + bed
->plt
->plt_reloc_offset
));
5982 reloc_index
/= sizeof (Elf32_External_Rel
);
5983 if (reloc_index
< count
)
5984 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5986 plt_offset
+= bed
->plt
->plt_entry_size
;
5988 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5990 if (plt_offset
>= plt
->size
)
5994 free (plt_contents
);
5999 /* Similar to _bfd_elf_get_synthetic_symtab. */
6002 elf_i386_get_synthetic_symtab (bfd
*abfd
,
6009 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
6010 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6011 dynsymcount
, dynsyms
, ret
,
6013 elf_i386_get_plt_sym_val
);
6016 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6019 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
6021 if (h
->plt
.offset
!= (bfd_vma
) -1
6023 && !h
->pointer_equality_needed
)
6026 return _bfd_elf_hash_symbol (h
);
6029 #define TARGET_LITTLE_SYM i386_elf32_vec
6030 #define TARGET_LITTLE_NAME "elf32-i386"
6031 #define ELF_ARCH bfd_arch_i386
6032 #define ELF_TARGET_ID I386_ELF_DATA
6033 #define ELF_MACHINE_CODE EM_386
6034 #define ELF_MAXPAGESIZE 0x1000
6036 #define elf_backend_can_gc_sections 1
6037 #define elf_backend_can_refcount 1
6038 #define elf_backend_want_got_plt 1
6039 #define elf_backend_plt_readonly 1
6040 #define elf_backend_want_plt_sym 0
6041 #define elf_backend_got_header_size 12
6042 #define elf_backend_plt_alignment 4
6043 #define elf_backend_dtrel_excludes_plt 1
6044 #define elf_backend_extern_protected_data 1
6045 #define elf_backend_caches_rawsize 1
6046 #define elf_backend_want_dynrelro 1
6048 /* Support RELA for objdump of prelink objects. */
6049 #define elf_info_to_howto elf_i386_info_to_howto_rel
6050 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6052 #define bfd_elf32_mkobject elf_i386_mkobject
6054 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6055 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6056 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6057 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6058 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6060 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6061 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6062 #define elf_backend_check_relocs elf_i386_check_relocs
6063 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6064 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
6065 #define elf_backend_fake_sections elf_i386_fake_sections
6066 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6067 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6068 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6069 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6070 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6071 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6072 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6073 #define elf_backend_relocate_section elf_i386_relocate_section
6074 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6075 #define elf_backend_always_size_sections elf_i386_always_size_sections
6076 #define elf_backend_omit_section_dynsym \
6077 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6078 #define elf_backend_hash_symbol elf_i386_hash_symbol
6079 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6081 #include "elf32-target.h"
6083 /* FreeBSD support. */
6085 #undef TARGET_LITTLE_SYM
6086 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6087 #undef TARGET_LITTLE_NAME
6088 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6090 #define ELF_OSABI ELFOSABI_FREEBSD
6092 /* The kernel recognizes executables as valid only if they carry a
6093 "FreeBSD" label in the ELF header. So we put this label on all
6094 executables and (for simplicity) also all other object files. */
6097 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
6099 _bfd_elf_post_process_headers (abfd
, info
);
6101 #ifdef OLD_FREEBSD_ABI_LABEL
6103 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6104 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6105 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
6110 #undef elf_backend_post_process_headers
6111 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6113 #define elf32_bed elf32_i386_fbsd_bed
6115 #undef elf_backend_add_symbol_hook
6117 #include "elf32-target.h"
6121 #undef TARGET_LITTLE_SYM
6122 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6123 #undef TARGET_LITTLE_NAME
6124 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6126 #undef elf_backend_post_process_headers
6128 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6129 objects won't be recognized. */
6133 #define elf32_bed elf32_i386_sol2_bed
6135 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6137 #undef elf_backend_static_tls_alignment
6138 #define elf_backend_static_tls_alignment 8
6140 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6142 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6144 #undef elf_backend_want_plt_sym
6145 #define elf_backend_want_plt_sym 1
6147 #undef elf_backend_strtab_flags
6148 #define elf_backend_strtab_flags SHF_STRINGS
6150 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6151 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6152 FALSE otherwise. ISECTION is the best guess matching section from the
6153 input bfd IBFD, but it might be NULL. */
6156 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6157 bfd
*obfd ATTRIBUTE_UNUSED
,
6158 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6159 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6161 /* PR 19938: FIXME: Need to add code for setting the sh_info
6162 and sh_link fields of Solaris specific section types. */
6165 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6166 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6168 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6170 The following values should be set:
6173 -----------------------------------------------------------------------------
6174 SHT_SUNW_ancillary The section header index of 0
6175 [0x6fffffee] the associated string table.
6177 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6178 [0x6ffffff0] the associated symbol table. section header index of
6180 SHT_SUNW_capchain table,
6183 SHT_SUNW_symsort The section header index of 0
6184 [0x6ffffff1] the associated symbol table.
6186 SHT_SUNW_tlssort The section header index of 0
6187 [0x6ffffff2] the associated symbol table.
6189 SHT_SUNW_LDYNSYM The section header index of One greater than the
6190 [0x6ffffff3] the associated string table. symbol table index of the
6191 This index is the same string last local symbol,
6192 table used by the SHT_DYNSYM STB_LOCAL. Since
6193 section. SHT_SUNW_LDYNSYM only
6194 contains local symbols,
6195 sh_info is equivalent to
6196 the number of symbols in
6199 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6200 [0x6ffffff5] the section header index of to named strings, the
6201 the associated section header index of
6202 SHT_SUNW_capinfo table, the associated string
6203 otherwise 0. table, otherwise 0.
6205 SHT_SUNW_move The section header index of 0
6206 [0x6ffffffa] the associated symbol table.
6211 SHT_SUNW_syminfo The section header index of The section header index
6212 [0x6ffffffc] the associated symbol table. of the associated
6215 SHT_SUNW_verdef The section header index of The number of version
6216 [0x6ffffffd] the associated string table. definitions within the
6219 SHT_SUNW_verneed The section header index of The number of version
6220 [0x6ffffffe] the associated string table. dependencies within the
6223 SHT_SUNW_versym The section header index of 0
6224 [0x6fffffff] the associated symbol table. */
6227 #undef elf_backend_copy_special_section_fields
6228 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6230 #include "elf32-target.h"
6232 /* Intel MCU support. */
6235 elf32_iamcu_elf_object_p (bfd
*abfd
)
6237 /* Set the right machine number for an IAMCU elf32 file. */
6238 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6242 #undef TARGET_LITTLE_SYM
6243 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6244 #undef TARGET_LITTLE_NAME
6245 #define TARGET_LITTLE_NAME "elf32-iamcu"
6247 #define ELF_ARCH bfd_arch_iamcu
6249 #undef ELF_MACHINE_CODE
6250 #define ELF_MACHINE_CODE EM_IAMCU
6255 #define elf32_bed elf32_iamcu_bed
6257 #undef elf_backend_object_p
6258 #define elf_backend_object_p elf32_iamcu_elf_object_p
6260 #undef elf_backend_static_tls_alignment
6262 #undef elf_backend_want_plt_sym
6263 #define elf_backend_want_plt_sym 0
6265 #undef elf_backend_strtab_flags
6266 #undef elf_backend_copy_special_section_fields
6268 #include "elf32-target.h"
6270 /* Restore defaults. */
6272 #define ELF_ARCH bfd_arch_i386
6273 #undef ELF_MACHINE_CODE
6274 #define ELF_MACHINE_CODE EM_386
6276 /* Native Client support. */
6278 #undef TARGET_LITTLE_SYM
6279 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6280 #undef TARGET_LITTLE_NAME
6281 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6283 #define elf32_bed elf32_i386_nacl_bed
6285 #undef ELF_MAXPAGESIZE
6286 #define ELF_MAXPAGESIZE 0x10000
6288 /* Restore defaults. */
6290 #undef elf_backend_want_plt_sym
6291 #define elf_backend_want_plt_sym 0
6292 #undef elf_backend_post_process_headers
6293 #undef elf_backend_static_tls_alignment
6295 /* NaCl uses substantially different PLT entries for the same effects. */
6297 #undef elf_backend_plt_alignment
6298 #define elf_backend_plt_alignment 5
6299 #define NACL_PLT_ENTRY_SIZE 64
6300 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6302 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6304 0xff, 0x35, /* pushl contents of address */
6305 0, 0, 0, 0, /* replaced with address of .got + 4. */
6306 0x8b, 0x0d, /* movl contents of address, %ecx */
6307 0, 0, 0, 0, /* replaced with address of .got + 8. */
6308 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6309 0xff, 0xe1 /* jmp *%ecx */
6312 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6314 0x8b, 0x0d, /* movl contents of address, %ecx */
6315 0, 0, 0, 0, /* replaced with GOT slot address. */
6316 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6317 0xff, 0xe1, /* jmp *%ecx */
6319 /* Pad to the next 32-byte boundary with nop instructions. */
6321 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6322 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6324 /* Lazy GOT entries point here (32-byte aligned). */
6325 0x68, /* pushl immediate */
6326 0, 0, 0, 0, /* replaced with reloc offset. */
6327 0xe9, /* jmp relative */
6328 0, 0, 0, 0, /* replaced with offset to .plt. */
6330 /* Pad to the next 32-byte boundary with nop instructions. */
6331 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6332 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6336 static const bfd_byte
6337 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6339 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6340 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6341 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6342 0xff, 0xe1, /* jmp *%ecx */
6344 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6345 so pad to that size with nop instructions. */
6346 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6349 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6351 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6352 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6353 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6354 0xff, 0xe1, /* jmp *%ecx */
6356 /* Pad to the next 32-byte boundary with nop instructions. */
6358 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6359 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6361 /* Lazy GOT entries point here (32-byte aligned). */
6362 0x68, /* pushl immediate */
6363 0, 0, 0, 0, /* replaced with offset into relocation table. */
6364 0xe9, /* jmp relative */
6365 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6367 /* Pad to the next 32-byte boundary with nop instructions. */
6368 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6369 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6373 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6375 #if (PLT_CIE_LENGTH != 20 \
6376 || PLT_FDE_LENGTH != 36 \
6377 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6378 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6379 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6381 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6382 0, 0, 0, 0, /* CIE ID */
6383 1, /* CIE version */
6384 'z', 'R', 0, /* Augmentation string */
6385 1, /* Code alignment factor */
6386 0x7c, /* Data alignment factor: -4 */
6387 8, /* Return address column */
6388 1, /* Augmentation size */
6389 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6390 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6391 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6392 DW_CFA_nop
, DW_CFA_nop
,
6394 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6395 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6396 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6397 0, 0, 0, 0, /* .plt size goes here */
6398 0, /* Augmentation size */
6399 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6400 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6401 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6402 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6403 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6404 13, /* Block length */
6405 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6406 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6407 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6408 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6409 DW_CFA_nop
, DW_CFA_nop
6412 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6414 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6415 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6416 2, /* plt0_got1_offset */
6417 8, /* plt0_got2_offset */
6418 elf_i386_nacl_plt_entry
, /* plt_entry */
6419 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6420 2, /* plt_got_offset */
6421 33, /* plt_reloc_offset */
6422 38, /* plt_plt_offset */
6423 32, /* plt_lazy_offset */
6424 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6425 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6426 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6427 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6430 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6432 &elf_i386_nacl_plt
, /* plt */
6433 0x90, /* plt0_pad_byte: nop insn */
6438 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6440 /* Set the right machine number for a NaCl i386 ELF32 file. */
6441 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6445 #undef elf_backend_arch_data
6446 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6448 #undef elf_backend_object_p
6449 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6450 #undef elf_backend_modify_segment_map
6451 #define elf_backend_modify_segment_map nacl_modify_segment_map
6452 #undef elf_backend_modify_program_headers
6453 #define elf_backend_modify_program_headers nacl_modify_program_headers
6454 #undef elf_backend_final_write_processing
6455 #define elf_backend_final_write_processing nacl_final_write_processing
6457 #include "elf32-target.h"
6459 /* Restore defaults. */
6460 #undef elf_backend_object_p
6461 #undef elf_backend_modify_segment_map
6462 #undef elf_backend_modify_program_headers
6463 #undef elf_backend_final_write_processing
6465 /* VxWorks support. */
6467 #undef TARGET_LITTLE_SYM
6468 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6469 #undef TARGET_LITTLE_NAME
6470 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6472 #undef elf_backend_plt_alignment
6473 #define elf_backend_plt_alignment 4
6475 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6477 &elf_i386_plt
, /* plt */
6478 0x90, /* plt0_pad_byte */
6482 #undef elf_backend_arch_data
6483 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6485 #undef elf_backend_relocs_compatible
6486 #undef elf_backend_add_symbol_hook
6487 #define elf_backend_add_symbol_hook \
6488 elf_vxworks_add_symbol_hook
6489 #undef elf_backend_link_output_symbol_hook
6490 #define elf_backend_link_output_symbol_hook \
6491 elf_vxworks_link_output_symbol_hook
6492 #undef elf_backend_emit_relocs
6493 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6494 #undef elf_backend_final_write_processing
6495 #define elf_backend_final_write_processing \
6496 elf_vxworks_final_write_processing
6497 #undef elf_backend_static_tls_alignment
6499 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6501 #undef elf_backend_want_plt_sym
6502 #define elf_backend_want_plt_sym 1
6505 #define elf32_bed elf32_i386_vxworks_bed
6507 #include "elf32-target.h"