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 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table
[indx
].type
!= r_type
)
393 return &elf_howto_table
[indx
];
397 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
399 Elf_Internal_Rela
*dst
)
401 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
402 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
405 /* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
412 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
414 if (name
[0] == '.' && name
[1] == 'X')
417 return _bfd_elf_is_local_label_name (abfd
, name
);
420 /* Support for core dump NOTE sections. */
423 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
428 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
430 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
436 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
439 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
443 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
447 switch (note
->descsz
)
452 case 144: /* Linux/i386 */
454 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
457 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
469 size
, note
->descpos
+ offset
);
473 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
475 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
477 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
482 elf_tdata (abfd
)->core
->program
483 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
484 elf_tdata (abfd
)->core
->command
485 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
489 switch (note
->descsz
)
494 case 124: /* Linux/i386 elf_prpsinfo. */
495 elf_tdata (abfd
)->core
->pid
496 = bfd_get_32 (abfd
, note
->descdata
+ 12);
497 elf_tdata (abfd
)->core
->program
498 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
499 elf_tdata (abfd
)->core
->command
500 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
508 char *command
= elf_tdata (abfd
)->core
->command
;
509 int n
= strlen (command
);
511 if (0 < n
&& command
[n
- 1] == ' ')
512 command
[n
- 1] = '\0';
518 /* Functions for the i386 ELF linker.
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
532 /* The name of the dynamic interpreter. This is put in the .interp
535 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the procedure linkage table. */
545 #define PLT_ENTRY_SIZE 16
547 /* The first entry in an absolute procedure linkage table looks like
548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
551 static const bfd_byte elf_i386_plt0_entry
[12] =
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0 /* replaced with address of .got + 8. */
559 /* Subsequent entries in an absolute procedure linkage table look like
562 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572 /* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
575 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
581 /* Subsequent entries in a PIC procedure linkage table look like this. */
583 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
593 /* Entries in the GOT procedure linkage table look like this. */
595 static const bfd_byte elf_i386_got_plt_entry
[8] =
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
602 /* Entries in the PIC GOT procedure linkage table look like this. */
604 static const bfd_byte elf_i386_pic_got_plt_entry
[8] =
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
611 /* .eh_frame covering the .plt section. */
613 static const bfd_byte elf_i386_eh_frame_plt
[] =
615 #define PLT_CIE_LENGTH 20
616 #define PLT_FDE_LENGTH 36
617 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
628 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop
, DW_CFA_nop
,
632 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
646 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
647 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
650 struct elf_i386_plt_layout
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte
*plt0_entry
;
654 unsigned int plt0_entry_size
;
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset
;
658 unsigned int plt0_got2_offset
;
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte
*plt_entry
;
662 unsigned int plt_entry_size
;
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset
;
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte
*pic_plt0_entry
;
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte
*pic_plt_entry
;
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte
*eh_frame_plt
;
680 unsigned int eh_frame_plt_size
;
683 #define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
686 /* These are the standard parameters. */
687 static const struct elf_i386_plt_layout elf_i386_plt
=
689 elf_i386_plt0_entry
, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry
), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry
, /* plt_entry */
694 PLT_ENTRY_SIZE
, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry
, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry
, /* pic_plt_entry */
701 elf_i386_eh_frame_plt
, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt
), /* eh_frame_plt_size */
706 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708 #define PLTRESOLVE_RELOCS_SHLIB 0
709 #define PLTRESOLVE_RELOCS 2
710 #define PLT_NON_JUMP_SLOT_RELOCS 2
712 /* Architecture-specific backend data for i386. */
714 struct elf_i386_backend_data
716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout
*plt
;
719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte
;
722 /* True if the target system is VxWorks. */
726 #define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
730 /* These are the standard parameters. */
731 static const struct elf_i386_backend_data elf_i386_arch_bed
=
733 &elf_i386_plt
, /* plt */
734 0, /* plt0_pad_byte */
738 #define elf_backend_arch_data &elf_i386_arch_bed
740 /* i386 ELF linker hash entry. */
742 struct elf_i386_link_hash_entry
744 struct elf_link_hash_entry elf
;
746 /* Track dynamic relocs copied for this symbol. */
747 struct elf_dyn_relocs
*dyn_relocs
;
749 #define GOT_UNKNOWN 0
753 #define GOT_TLS_IE_POS 5
754 #define GOT_TLS_IE_NEG 6
755 #define GOT_TLS_IE_BOTH 7
756 #define GOT_TLS_GDESC 8
757 #define GOT_TLS_GD_BOTH_P(type) \
758 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
759 #define GOT_TLS_GD_P(type) \
760 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
761 #define GOT_TLS_GDESC_P(type) \
762 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
763 #define GOT_TLS_GD_ANY_P(type) \
764 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
765 unsigned char tls_type
;
767 /* Symbol is referenced by R_386_GOTOFF relocation. */
768 unsigned int gotoff_ref
: 1;
770 /* Reference count of C/C++ function pointer relocations in read-write
771 section which can be resolved at run-time. */
772 bfd_signed_vma func_pointer_refcount
;
774 /* Information about the GOT PLT entry. Filled when there are both
775 GOT and PLT relocations against the same function. */
776 union gotplt_union plt_got
;
778 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
779 starting at the end of the jump table. */
783 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
785 struct elf_i386_obj_tdata
787 struct elf_obj_tdata root
;
789 /* tls_type for each local got entry. */
790 char *local_got_tls_type
;
792 /* GOTPLT entries for TLS descriptors. */
793 bfd_vma
*local_tlsdesc_gotent
;
796 #define elf_i386_tdata(abfd) \
797 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
799 #define elf_i386_local_got_tls_type(abfd) \
800 (elf_i386_tdata (abfd)->local_got_tls_type)
802 #define elf_i386_local_tlsdesc_gotent(abfd) \
803 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
805 #define is_i386_elf(bfd) \
806 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
807 && elf_tdata (bfd) != NULL \
808 && elf_object_id (bfd) == I386_ELF_DATA)
811 elf_i386_mkobject (bfd
*abfd
)
813 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
817 /* i386 ELF linker hash table. */
819 struct elf_i386_link_hash_table
821 struct elf_link_hash_table elf
;
823 /* Short-cuts to get to dynamic linker sections. */
826 asection
*plt_eh_frame
;
831 bfd_signed_vma refcount
;
835 /* The amount of space used by the reserved portion of the sgotplt
836 section, plus whatever space is used by the jump slots. */
837 bfd_vma sgotplt_jump_table_size
;
839 /* Small local sym cache. */
840 struct sym_cache sym_cache
;
842 /* _TLS_MODULE_BASE_ symbol. */
843 struct bfd_link_hash_entry
*tls_module_base
;
845 /* Used by local STT_GNU_IFUNC symbols. */
846 htab_t loc_hash_table
;
847 void * loc_hash_memory
;
849 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
852 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
853 bfd_vma next_tls_desc_index
;
855 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
856 bfd_vma next_jump_slot_index
;
858 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
859 bfd_vma next_irelative_index
;
862 /* Get the i386 ELF linker hash table from a link_info structure. */
864 #define elf_i386_hash_table(p) \
865 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
866 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
868 #define elf_i386_compute_jump_table_size(htab) \
869 ((htab)->elf.srelplt->reloc_count * 4)
871 /* Create an entry in an i386 ELF linker hash table. */
873 static struct bfd_hash_entry
*
874 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
875 struct bfd_hash_table
*table
,
878 /* Allocate the structure if it has not already been allocated by a
882 entry
= (struct bfd_hash_entry
*)
883 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
888 /* Call the allocation method of the superclass. */
889 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
892 struct elf_i386_link_hash_entry
*eh
;
894 eh
= (struct elf_i386_link_hash_entry
*) entry
;
895 eh
->dyn_relocs
= NULL
;
896 eh
->tls_type
= GOT_UNKNOWN
;
898 eh
->func_pointer_refcount
= 0;
899 eh
->plt_got
.offset
= (bfd_vma
) -1;
900 eh
->tlsdesc_got
= (bfd_vma
) -1;
906 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
907 for local symbol so that we can handle local STT_GNU_IFUNC symbols
908 as global symbol. We reuse indx and dynstr_index for local symbol
909 hash since they aren't used by global symbols in this backend. */
912 elf_i386_local_htab_hash (const void *ptr
)
914 struct elf_link_hash_entry
*h
915 = (struct elf_link_hash_entry
*) ptr
;
916 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
919 /* Compare local hash entries. */
922 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
924 struct elf_link_hash_entry
*h1
925 = (struct elf_link_hash_entry
*) ptr1
;
926 struct elf_link_hash_entry
*h2
927 = (struct elf_link_hash_entry
*) ptr2
;
929 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
932 /* Find and/or create a hash entry for local symbol. */
934 static struct elf_link_hash_entry
*
935 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
936 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
939 struct elf_i386_link_hash_entry e
, *ret
;
940 asection
*sec
= abfd
->sections
;
941 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
942 ELF32_R_SYM (rel
->r_info
));
945 e
.elf
.indx
= sec
->id
;
946 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
947 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
948 create
? INSERT
: NO_INSERT
);
955 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
959 ret
= (struct elf_i386_link_hash_entry
*)
960 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
961 sizeof (struct elf_i386_link_hash_entry
));
964 memset (ret
, 0, sizeof (*ret
));
965 ret
->elf
.indx
= sec
->id
;
966 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
967 ret
->elf
.dynindx
= -1;
968 ret
->func_pointer_refcount
= 0;
969 ret
->plt_got
.offset
= (bfd_vma
) -1;
975 /* Destroy an i386 ELF linker hash table. */
978 elf_i386_link_hash_table_free (bfd
*obfd
)
980 struct elf_i386_link_hash_table
*htab
981 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
983 if (htab
->loc_hash_table
)
984 htab_delete (htab
->loc_hash_table
);
985 if (htab
->loc_hash_memory
)
986 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
987 _bfd_elf_link_hash_table_free (obfd
);
990 /* Create an i386 ELF linker hash table. */
992 static struct bfd_link_hash_table
*
993 elf_i386_link_hash_table_create (bfd
*abfd
)
995 struct elf_i386_link_hash_table
*ret
;
996 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
998 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1002 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1003 elf_i386_link_hash_newfunc
,
1004 sizeof (struct elf_i386_link_hash_entry
),
1011 ret
->loc_hash_table
= htab_try_create (1024,
1012 elf_i386_local_htab_hash
,
1013 elf_i386_local_htab_eq
,
1015 ret
->loc_hash_memory
= objalloc_create ();
1016 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1018 elf_i386_link_hash_table_free (abfd
);
1021 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1023 return &ret
->elf
.root
;
1026 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1027 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1031 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1033 struct elf_i386_link_hash_table
*htab
;
1035 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1038 htab
= elf_i386_hash_table (info
);
1042 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1046 if (bfd_link_executable (info
))
1048 /* Always allow copy relocs for building executables. */
1049 asection
*s
= bfd_get_linker_section (dynobj
, ".rel.bss");
1052 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1053 s
= bfd_make_section_anyway_with_flags (dynobj
,
1055 (bed
->dynamic_sec_flags
1058 || ! bfd_set_section_alignment (dynobj
, s
,
1059 bed
->s
->log_file_align
))
1065 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1066 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1070 if (!info
->no_ld_generated_unwind_info
1071 && htab
->plt_eh_frame
== NULL
1072 && htab
->elf
.splt
!= NULL
)
1074 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1075 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1076 | SEC_LINKER_CREATED
);
1078 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1079 if (htab
->plt_eh_frame
== NULL
1080 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1087 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1090 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1091 struct elf_link_hash_entry
*dir
,
1092 struct elf_link_hash_entry
*ind
)
1094 struct elf_i386_link_hash_entry
*edir
, *eind
;
1096 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1097 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1099 if (eind
->dyn_relocs
!= NULL
)
1101 if (edir
->dyn_relocs
!= NULL
)
1103 struct elf_dyn_relocs
**pp
;
1104 struct elf_dyn_relocs
*p
;
1106 /* Add reloc counts against the indirect sym to the direct sym
1107 list. Merge any entries against the same section. */
1108 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1110 struct elf_dyn_relocs
*q
;
1112 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1113 if (q
->sec
== p
->sec
)
1115 q
->pc_count
+= p
->pc_count
;
1116 q
->count
+= p
->count
;
1123 *pp
= edir
->dyn_relocs
;
1126 edir
->dyn_relocs
= eind
->dyn_relocs
;
1127 eind
->dyn_relocs
= NULL
;
1130 if (ind
->root
.type
== bfd_link_hash_indirect
1131 && dir
->got
.refcount
<= 0)
1133 edir
->tls_type
= eind
->tls_type
;
1134 eind
->tls_type
= GOT_UNKNOWN
;
1137 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1138 generate a R_386_COPY reloc. */
1139 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1141 if (ELIMINATE_COPY_RELOCS
1142 && ind
->root
.type
!= bfd_link_hash_indirect
1143 && dir
->dynamic_adjusted
)
1145 /* If called to transfer flags for a weakdef during processing
1146 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1147 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1148 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1149 dir
->ref_regular
|= ind
->ref_regular
;
1150 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1151 dir
->needs_plt
|= ind
->needs_plt
;
1152 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1156 if (eind
->func_pointer_refcount
> 0)
1158 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1159 eind
->func_pointer_refcount
= 0;
1162 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1166 /* Return TRUE if the TLS access code sequence support transition
1170 elf_i386_check_tls_transition (bfd
*abfd
, asection
*sec
,
1172 Elf_Internal_Shdr
*symtab_hdr
,
1173 struct elf_link_hash_entry
**sym_hashes
,
1174 unsigned int r_type
,
1175 const Elf_Internal_Rela
*rel
,
1176 const Elf_Internal_Rela
*relend
)
1178 unsigned int val
, type
;
1179 unsigned long r_symndx
;
1180 struct elf_link_hash_entry
*h
;
1183 /* Get the section contents. */
1184 if (contents
== NULL
)
1186 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1187 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1190 /* FIXME: How to better handle error condition? */
1191 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1194 /* Cache the section contents for elf_link_input_bfd. */
1195 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1199 offset
= rel
->r_offset
;
1204 if (offset
< 2 || (rel
+ 1) >= relend
)
1207 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1208 if (r_type
== R_386_TLS_GD
)
1210 /* Check transition from GD access model. Only
1211 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1212 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1213 can transit to different access model. */
1214 if ((offset
+ 10) > sec
->size
||
1215 (type
!= 0x8d && type
!= 0x04))
1218 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1221 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1225 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
1228 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
1233 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1234 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1237 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1243 /* Check transition from LD access model. Only
1244 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1245 can transit to different access model. */
1246 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1249 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1250 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1254 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1257 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1258 if (r_symndx
< symtab_hdr
->sh_info
)
1261 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1262 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1263 may be versioned. */
1265 && h
->root
.root
.string
!= NULL
1266 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1267 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1268 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1272 /* Check transition from IE access model:
1273 movl foo@indntpoff(%rip), %eax
1274 movl foo@indntpoff(%rip), %reg
1275 addl foo@indntpoff(%rip), %reg
1278 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1281 /* Check "movl foo@tpoff(%rip), %eax" first. */
1282 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1289 /* Check movl|addl foo@tpoff(%rip), %reg. */
1290 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1291 return ((type
== 0x8b || type
== 0x03)
1292 && (val
& 0xc7) == 0x05);
1294 case R_386_TLS_GOTIE
:
1295 case R_386_TLS_IE_32
:
1296 /* Check transition from {IE_32,GOTIE} access model:
1297 subl foo@{tpoff,gontoff}(%reg1), %reg2
1298 movl foo@{tpoff,gontoff}(%reg1), %reg2
1299 addl foo@{tpoff,gontoff}(%reg1), %reg2
1302 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1305 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1306 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1309 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1310 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1312 case R_386_TLS_GOTDESC
:
1313 /* Check transition from GDesc access model:
1314 leal x@tlsdesc(%ebx), %eax
1316 Make sure it's a leal adding ebx to a 32-bit offset
1317 into any register, although it's probably almost always
1320 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1323 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1326 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1327 return (val
& 0xc7) == 0x83;
1329 case R_386_TLS_DESC_CALL
:
1330 /* Check transition from GDesc access model:
1331 call *x@tlsdesc(%rax)
1333 if (offset
+ 2 <= sec
->size
)
1335 /* Make sure that it's a call *x@tlsdesc(%rax). */
1336 static const unsigned char call
[] = { 0xff, 0x10 };
1337 return memcmp (contents
+ offset
, call
, 2) == 0;
1347 /* Return TRUE if the TLS access transition is OK or no transition
1348 will be performed. Update R_TYPE if there is a transition. */
1351 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1352 asection
*sec
, bfd_byte
*contents
,
1353 Elf_Internal_Shdr
*symtab_hdr
,
1354 struct elf_link_hash_entry
**sym_hashes
,
1355 unsigned int *r_type
, int tls_type
,
1356 const Elf_Internal_Rela
*rel
,
1357 const Elf_Internal_Rela
*relend
,
1358 struct elf_link_hash_entry
*h
,
1359 unsigned long r_symndx
)
1361 unsigned int from_type
= *r_type
;
1362 unsigned int to_type
= from_type
;
1363 bfd_boolean check
= TRUE
;
1365 /* Skip TLS transition for functions. */
1367 && (h
->type
== STT_FUNC
1368 || h
->type
== STT_GNU_IFUNC
))
1374 case R_386_TLS_GOTDESC
:
1375 case R_386_TLS_DESC_CALL
:
1376 case R_386_TLS_IE_32
:
1378 case R_386_TLS_GOTIE
:
1379 if (bfd_link_executable (info
))
1382 to_type
= R_386_TLS_LE_32
;
1383 else if (from_type
!= R_386_TLS_IE
1384 && from_type
!= R_386_TLS_GOTIE
)
1385 to_type
= R_386_TLS_IE_32
;
1388 /* When we are called from elf_i386_relocate_section, CONTENTS
1389 isn't NULL and there may be additional transitions based on
1391 if (contents
!= NULL
)
1393 unsigned int new_to_type
= to_type
;
1395 if (bfd_link_executable (info
)
1398 && (tls_type
& GOT_TLS_IE
))
1399 new_to_type
= R_386_TLS_LE_32
;
1401 if (to_type
== R_386_TLS_GD
1402 || to_type
== R_386_TLS_GOTDESC
1403 || to_type
== R_386_TLS_DESC_CALL
)
1405 if (tls_type
== GOT_TLS_IE_POS
)
1406 new_to_type
= R_386_TLS_GOTIE
;
1407 else if (tls_type
& GOT_TLS_IE
)
1408 new_to_type
= R_386_TLS_IE_32
;
1411 /* We checked the transition before when we were called from
1412 elf_i386_check_relocs. We only want to check the new
1413 transition which hasn't been checked before. */
1414 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1415 to_type
= new_to_type
;
1421 if (bfd_link_executable (info
))
1422 to_type
= R_386_TLS_LE_32
;
1429 /* Return TRUE if there is no transition. */
1430 if (from_type
== to_type
)
1433 /* Check if the transition can be performed. */
1435 && ! elf_i386_check_tls_transition (abfd
, sec
, contents
,
1436 symtab_hdr
, sym_hashes
,
1437 from_type
, rel
, relend
))
1439 reloc_howto_type
*from
, *to
;
1442 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1443 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1446 name
= h
->root
.root
.string
;
1449 struct elf_i386_link_hash_table
*htab
;
1451 htab
= elf_i386_hash_table (info
);
1456 Elf_Internal_Sym
*isym
;
1458 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1460 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1464 (*_bfd_error_handler
)
1465 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1466 "in section `%A' failed"),
1467 abfd
, sec
, from
->name
, to
->name
, name
,
1468 (unsigned long) rel
->r_offset
);
1469 bfd_set_error (bfd_error_bad_value
);
1477 /* Rename some of the generic section flags to better document how they
1479 #define need_convert_load sec_flg0
1481 /* Look through the relocs for a section during the first phase, and
1482 calculate needed space in the global offset table, procedure linkage
1483 table, and dynamic reloc sections. */
1486 elf_i386_check_relocs (bfd
*abfd
,
1487 struct bfd_link_info
*info
,
1489 const Elf_Internal_Rela
*relocs
)
1491 struct elf_i386_link_hash_table
*htab
;
1492 Elf_Internal_Shdr
*symtab_hdr
;
1493 struct elf_link_hash_entry
**sym_hashes
;
1494 const Elf_Internal_Rela
*rel
;
1495 const Elf_Internal_Rela
*rel_end
;
1497 bfd_boolean use_plt_got
;
1499 if (bfd_link_relocatable (info
))
1502 BFD_ASSERT (is_i386_elf (abfd
));
1504 htab
= elf_i386_hash_table (info
);
1508 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1509 && (get_elf_i386_backend_data (abfd
)
1510 == &elf_i386_arch_bed
));
1512 symtab_hdr
= &elf_symtab_hdr (abfd
);
1513 sym_hashes
= elf_sym_hashes (abfd
);
1517 rel_end
= relocs
+ sec
->reloc_count
;
1518 for (rel
= relocs
; rel
< rel_end
; rel
++)
1520 unsigned int r_type
;
1521 unsigned long r_symndx
;
1522 struct elf_link_hash_entry
*h
;
1523 struct elf_i386_link_hash_entry
*eh
;
1524 Elf_Internal_Sym
*isym
;
1526 bfd_boolean size_reloc
;
1528 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1529 r_type
= ELF32_R_TYPE (rel
->r_info
);
1531 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1533 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1539 if (r_symndx
< symtab_hdr
->sh_info
)
1541 /* A local symbol. */
1542 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1547 /* Check relocation against local STT_GNU_IFUNC symbol. */
1548 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1550 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1554 /* Fake a STT_GNU_IFUNC symbol. */
1555 h
->type
= STT_GNU_IFUNC
;
1558 h
->forced_local
= 1;
1559 h
->root
.type
= bfd_link_hash_defined
;
1567 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1568 while (h
->root
.type
== bfd_link_hash_indirect
1569 || h
->root
.type
== bfd_link_hash_warning
)
1570 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1573 eh
= (struct elf_i386_link_hash_entry
*) h
;
1576 /* Create the ifunc sections for static executables. If we
1577 never see an indirect function symbol nor we are building
1578 a static executable, those sections will be empty and
1579 won't appear in output. */
1592 if (htab
->elf
.dynobj
== NULL
)
1593 htab
->elf
.dynobj
= abfd
;
1594 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1599 /* It is referenced by a non-shared object. */
1601 h
->root
.non_ir_ref
= 1;
1603 if (h
->type
== STT_GNU_IFUNC
)
1604 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1605 |= elf_gnu_symbol_ifunc
;
1608 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1609 symtab_hdr
, sym_hashes
,
1610 &r_type
, GOT_UNKNOWN
,
1611 rel
, rel_end
, h
, r_symndx
))
1617 htab
->tls_ldm_got
.refcount
+= 1;
1621 /* This symbol requires a procedure linkage table entry. We
1622 actually build the entry in adjust_dynamic_symbol,
1623 because this might be a case of linking PIC code which is
1624 never referenced by a dynamic object, in which case we
1625 don't need to generate a procedure linkage table entry
1628 /* If this is a local symbol, we resolve it directly without
1629 creating a procedure linkage table entry. */
1634 h
->plt
.refcount
+= 1;
1641 case R_386_TLS_IE_32
:
1643 case R_386_TLS_GOTIE
:
1644 if (!bfd_link_executable (info
))
1645 info
->flags
|= DF_STATIC_TLS
;
1651 case R_386_TLS_GOTDESC
:
1652 case R_386_TLS_DESC_CALL
:
1653 /* This symbol requires a global offset table entry. */
1655 int tls_type
, old_tls_type
;
1662 tls_type
= GOT_NORMAL
;
1664 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1665 case R_386_TLS_GOTDESC
:
1666 case R_386_TLS_DESC_CALL
:
1667 tls_type
= GOT_TLS_GDESC
; break;
1668 case R_386_TLS_IE_32
:
1669 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1670 tls_type
= GOT_TLS_IE_NEG
;
1672 /* If this is a GD->IE transition, we may use either of
1673 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1674 tls_type
= GOT_TLS_IE
;
1677 case R_386_TLS_GOTIE
:
1678 tls_type
= GOT_TLS_IE_POS
; break;
1683 h
->got
.refcount
+= 1;
1684 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1688 bfd_signed_vma
*local_got_refcounts
;
1690 /* This is a global offset table entry for a local symbol. */
1691 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1692 if (local_got_refcounts
== NULL
)
1696 size
= symtab_hdr
->sh_info
;
1697 size
*= (sizeof (bfd_signed_vma
)
1698 + sizeof (bfd_vma
) + sizeof(char));
1699 local_got_refcounts
= (bfd_signed_vma
*)
1700 bfd_zalloc (abfd
, size
);
1701 if (local_got_refcounts
== NULL
)
1703 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1704 elf_i386_local_tlsdesc_gotent (abfd
)
1705 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1706 elf_i386_local_got_tls_type (abfd
)
1707 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1709 local_got_refcounts
[r_symndx
] += 1;
1710 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1713 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1714 tls_type
|= old_tls_type
;
1715 /* If a TLS symbol is accessed using IE at least once,
1716 there is no point to use dynamic model for it. */
1717 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1718 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1719 || (tls_type
& GOT_TLS_IE
) == 0))
1721 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1722 tls_type
= old_tls_type
;
1723 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1724 && GOT_TLS_GD_ANY_P (tls_type
))
1725 tls_type
|= old_tls_type
;
1729 name
= h
->root
.root
.string
;
1731 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1733 (*_bfd_error_handler
)
1734 (_("%B: `%s' accessed both as normal and "
1735 "thread local symbol"),
1737 bfd_set_error (bfd_error_bad_value
);
1742 if (old_tls_type
!= tls_type
)
1745 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1747 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1755 if (htab
->elf
.sgot
== NULL
)
1757 if (htab
->elf
.dynobj
== NULL
)
1758 htab
->elf
.dynobj
= abfd
;
1759 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
1762 if (r_type
!= R_386_TLS_IE
)
1766 case R_386_TLS_LE_32
:
1768 if (bfd_link_executable (info
))
1770 info
->flags
|= DF_STATIC_TLS
;
1775 if (h
!= NULL
&& bfd_link_executable (info
))
1777 /* If this reloc is in a read-only section, we might
1778 need a copy reloc. We can't check reliably at this
1779 stage whether the section is read-only, as input
1780 sections have not yet been mapped to output sections.
1781 Tentatively set the flag for now, and correct in
1782 adjust_dynamic_symbol. */
1785 /* We may need a .plt entry if the function this reloc
1786 refers to is in a shared lib. */
1787 h
->plt
.refcount
+= 1;
1788 if (r_type
== R_386_PC32
)
1790 /* Since something like ".long foo - ." may be used
1791 as pointer, make sure that PLT is used if foo is
1792 a function defined in a shared library. */
1793 if ((sec
->flags
& SEC_CODE
) == 0)
1794 h
->pointer_equality_needed
= 1;
1798 h
->pointer_equality_needed
= 1;
1799 /* R_386_32 can be resolved at run-time. */
1800 if (r_type
== R_386_32
1801 && (sec
->flags
& SEC_READONLY
) == 0)
1802 eh
->func_pointer_refcount
+= 1;
1808 /* If we are creating a shared library, and this is a reloc
1809 against a global symbol, or a non PC relative reloc
1810 against a local symbol, then we need to copy the reloc
1811 into the shared library. However, if we are linking with
1812 -Bsymbolic, we do not need to copy a reloc against a
1813 global symbol which is defined in an object we are
1814 including in the link (i.e., DEF_REGULAR is set). At
1815 this point we have not seen all the input files, so it is
1816 possible that DEF_REGULAR is not set now but will be set
1817 later (it is never cleared). In case of a weak definition,
1818 DEF_REGULAR may be cleared later by a strong definition in
1819 a shared library. We account for that possibility below by
1820 storing information in the relocs_copied field of the hash
1821 table entry. A similar situation occurs when creating
1822 shared libraries and symbol visibility changes render the
1825 If on the other hand, we are creating an executable, we
1826 may need to keep relocations for symbols satisfied by a
1827 dynamic library if we manage to avoid copy relocs for the
1829 if ((bfd_link_pic (info
)
1830 && (sec
->flags
& SEC_ALLOC
) != 0
1831 && (r_type
!= R_386_PC32
1833 && (! SYMBOLIC_BIND (info
, h
)
1834 || h
->root
.type
== bfd_link_hash_defweak
1835 || !h
->def_regular
))))
1836 || (ELIMINATE_COPY_RELOCS
1837 && !bfd_link_pic (info
)
1838 && (sec
->flags
& SEC_ALLOC
) != 0
1840 && (h
->root
.type
== bfd_link_hash_defweak
1841 || !h
->def_regular
)))
1843 struct elf_dyn_relocs
*p
;
1844 struct elf_dyn_relocs
**head
;
1846 /* We must copy these reloc types into the output file.
1847 Create a reloc section in dynobj and make room for
1851 if (htab
->elf
.dynobj
== NULL
)
1852 htab
->elf
.dynobj
= abfd
;
1854 sreloc
= _bfd_elf_make_dynamic_reloc_section
1855 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1861 /* If this is a global symbol, we count the number of
1862 relocations we need for this symbol. */
1865 head
= &eh
->dyn_relocs
;
1869 /* Track dynamic relocs needed for local syms too.
1870 We really need local syms available to do this
1875 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1880 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1884 vpp
= &elf_section_data (s
)->local_dynrel
;
1885 head
= (struct elf_dyn_relocs
**)vpp
;
1889 if (p
== NULL
|| p
->sec
!= sec
)
1891 bfd_size_type amt
= sizeof *p
;
1892 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
1904 /* Count size relocation as PC-relative relocation. */
1905 if (r_type
== R_386_PC32
|| size_reloc
)
1910 /* This relocation describes the C++ object vtable hierarchy.
1911 Reconstruct it for later use during GC. */
1912 case R_386_GNU_VTINHERIT
:
1913 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1917 /* This relocation describes which C++ vtable entries are actually
1918 used. Record for later use during GC. */
1919 case R_386_GNU_VTENTRY
:
1920 BFD_ASSERT (h
!= NULL
);
1922 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1932 && h
->plt
.refcount
> 0
1933 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
1934 || h
->got
.refcount
> 0)
1935 && htab
->plt_got
== NULL
)
1937 /* Create the GOT procedure linkage table. */
1938 unsigned int plt_got_align
;
1939 const struct elf_backend_data
*bed
;
1941 bed
= get_elf_backend_data (info
->output_bfd
);
1942 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
1943 && (sizeof (elf_i386_got_plt_entry
)
1944 == sizeof (elf_i386_pic_got_plt_entry
)));
1947 if (htab
->elf
.dynobj
== NULL
)
1948 htab
->elf
.dynobj
= abfd
;
1950 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1952 (bed
->dynamic_sec_flags
1957 if (htab
->plt_got
== NULL
1958 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1964 if ((r_type
== R_386_GOT32
|| r_type
== R_386_GOT32X
)
1965 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
1966 sec
->need_convert_load
= 1;
1972 /* Return the section that should be marked against GC for a given
1976 elf_i386_gc_mark_hook (asection
*sec
,
1977 struct bfd_link_info
*info
,
1978 Elf_Internal_Rela
*rel
,
1979 struct elf_link_hash_entry
*h
,
1980 Elf_Internal_Sym
*sym
)
1983 switch (ELF32_R_TYPE (rel
->r_info
))
1985 case R_386_GNU_VTINHERIT
:
1986 case R_386_GNU_VTENTRY
:
1990 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1993 /* Update the got entry reference counts for the section being removed. */
1996 elf_i386_gc_sweep_hook (bfd
*abfd
,
1997 struct bfd_link_info
*info
,
1999 const Elf_Internal_Rela
*relocs
)
2001 struct elf_i386_link_hash_table
*htab
;
2002 Elf_Internal_Shdr
*symtab_hdr
;
2003 struct elf_link_hash_entry
**sym_hashes
;
2004 bfd_signed_vma
*local_got_refcounts
;
2005 const Elf_Internal_Rela
*rel
, *relend
;
2007 if (bfd_link_relocatable (info
))
2010 htab
= elf_i386_hash_table (info
);
2014 elf_section_data (sec
)->local_dynrel
= NULL
;
2016 symtab_hdr
= &elf_symtab_hdr (abfd
);
2017 sym_hashes
= elf_sym_hashes (abfd
);
2018 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2020 relend
= relocs
+ sec
->reloc_count
;
2021 for (rel
= relocs
; rel
< relend
; rel
++)
2023 unsigned long r_symndx
;
2024 unsigned int r_type
;
2025 struct elf_link_hash_entry
*h
= NULL
;
2027 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2028 if (r_symndx
>= symtab_hdr
->sh_info
)
2030 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2031 while (h
->root
.type
== bfd_link_hash_indirect
2032 || h
->root
.type
== bfd_link_hash_warning
)
2033 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2037 /* A local symbol. */
2038 Elf_Internal_Sym
*isym
;
2040 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2043 /* Check relocation against local STT_GNU_IFUNC symbol. */
2045 && ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2047 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2055 struct elf_i386_link_hash_entry
*eh
;
2056 struct elf_dyn_relocs
**pp
;
2057 struct elf_dyn_relocs
*p
;
2059 eh
= (struct elf_i386_link_hash_entry
*) h
;
2060 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2063 /* Everything must go for SEC. */
2069 r_type
= ELF32_R_TYPE (rel
->r_info
);
2070 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
2071 symtab_hdr
, sym_hashes
,
2072 &r_type
, GOT_UNKNOWN
,
2073 rel
, relend
, h
, r_symndx
))
2079 if (htab
->tls_ldm_got
.refcount
> 0)
2080 htab
->tls_ldm_got
.refcount
-= 1;
2084 case R_386_TLS_GOTDESC
:
2085 case R_386_TLS_DESC_CALL
:
2086 case R_386_TLS_IE_32
:
2088 case R_386_TLS_GOTIE
:
2093 if (h
->got
.refcount
> 0)
2094 h
->got
.refcount
-= 1;
2095 if (h
->type
== STT_GNU_IFUNC
)
2097 if (h
->plt
.refcount
> 0)
2098 h
->plt
.refcount
-= 1;
2101 else if (local_got_refcounts
!= NULL
)
2103 if (local_got_refcounts
[r_symndx
] > 0)
2104 local_got_refcounts
[r_symndx
] -= 1;
2111 if (bfd_link_pic (info
)
2112 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2119 if (h
->plt
.refcount
> 0)
2120 h
->plt
.refcount
-= 1;
2121 if (r_type
== R_386_32
2122 && (sec
->flags
& SEC_READONLY
) == 0)
2124 struct elf_i386_link_hash_entry
*eh
2125 = (struct elf_i386_link_hash_entry
*) h
;
2126 if (eh
->func_pointer_refcount
> 0)
2127 eh
->func_pointer_refcount
-= 1;
2133 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
2135 if (h
->got
.refcount
> 0)
2136 h
->got
.refcount
-= 1;
2137 if (h
->plt
.refcount
> 0)
2138 h
->plt
.refcount
-= 1;
2150 /* Adjust a symbol defined by a dynamic object and referenced by a
2151 regular object. The current definition is in some section of the
2152 dynamic object, but we're not including those sections. We have to
2153 change the definition to something the rest of the link can
2157 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2158 struct elf_link_hash_entry
*h
)
2160 struct elf_i386_link_hash_table
*htab
;
2162 struct elf_i386_link_hash_entry
*eh
;
2163 struct elf_dyn_relocs
*p
;
2165 /* STT_GNU_IFUNC symbol must go through PLT. */
2166 if (h
->type
== STT_GNU_IFUNC
)
2168 /* All local STT_GNU_IFUNC references must be treate as local
2169 calls via local PLT. */
2171 && SYMBOL_CALLS_LOCAL (info
, h
))
2173 bfd_size_type pc_count
= 0, count
= 0;
2174 struct elf_dyn_relocs
**pp
;
2176 eh
= (struct elf_i386_link_hash_entry
*) h
;
2177 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2179 pc_count
+= p
->pc_count
;
2180 p
->count
-= p
->pc_count
;
2189 if (pc_count
|| count
)
2193 if (h
->plt
.refcount
<= 0)
2194 h
->plt
.refcount
= 1;
2196 h
->plt
.refcount
+= 1;
2200 if (h
->plt
.refcount
<= 0)
2202 h
->plt
.offset
= (bfd_vma
) -1;
2208 /* If this is a function, put it in the procedure linkage table. We
2209 will fill in the contents of the procedure linkage table later,
2210 when we know the address of the .got section. */
2211 if (h
->type
== STT_FUNC
2214 if (h
->plt
.refcount
<= 0
2215 || SYMBOL_CALLS_LOCAL (info
, h
)
2216 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2217 && h
->root
.type
== bfd_link_hash_undefweak
))
2219 /* This case can occur if we saw a PLT32 reloc in an input
2220 file, but the symbol was never referred to by a dynamic
2221 object, or if all references were garbage collected. In
2222 such a case, we don't actually need to build a procedure
2223 linkage table, and we can just do a PC32 reloc instead. */
2224 h
->plt
.offset
= (bfd_vma
) -1;
2231 /* It's possible that we incorrectly decided a .plt reloc was
2232 needed for an R_386_PC32 reloc to a non-function sym in
2233 check_relocs. We can't decide accurately between function and
2234 non-function syms in check-relocs; Objects loaded later in
2235 the link may change h->type. So fix it now. */
2236 h
->plt
.offset
= (bfd_vma
) -1;
2238 /* If this is a weak symbol, and there is a real definition, the
2239 processor independent code will have arranged for us to see the
2240 real definition first, and we can just use the same value. */
2241 if (h
->u
.weakdef
!= NULL
)
2243 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2244 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2245 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2246 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2247 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2248 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2252 /* This is a reference to a symbol defined by a dynamic object which
2253 is not a function. */
2255 /* If we are creating a shared library, we must presume that the
2256 only references to the symbol are via the global offset table.
2257 For such cases we need not do anything here; the relocations will
2258 be handled correctly by relocate_section. */
2259 if (!bfd_link_executable (info
))
2262 /* If there are no references to this symbol that do not use the
2263 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2265 eh
= (struct elf_i386_link_hash_entry
*) h
;
2266 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2269 /* If -z nocopyreloc was given, we won't generate them either. */
2270 if (info
->nocopyreloc
)
2276 htab
= elf_i386_hash_table (info
);
2280 /* If there aren't any dynamic relocs in read-only sections nor
2281 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2282 avoid the copy reloc. This doesn't work on VxWorks, where we can
2283 not have dynamic relocations (other than copy and jump slot
2284 relocations) in an executable. */
2285 if (ELIMINATE_COPY_RELOCS
2287 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2289 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2291 s
= p
->sec
->output_section
;
2292 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2303 /* We must allocate the symbol in our .dynbss section, which will
2304 become part of the .bss section of the executable. There will be
2305 an entry for this symbol in the .dynsym section. The dynamic
2306 object will contain position independent code, so all references
2307 from the dynamic object to this symbol will go through the global
2308 offset table. The dynamic linker will use the .dynsym entry to
2309 determine the address it must put in the global offset table, so
2310 both the dynamic object and the regular object will refer to the
2311 same memory location for the variable. */
2313 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2314 copy the initial value out of the dynamic object and into the
2315 runtime process image. */
2316 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2318 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2324 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2327 /* Allocate space in .plt, .got and associated reloc sections for
2331 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2333 struct bfd_link_info
*info
;
2334 struct elf_i386_link_hash_table
*htab
;
2335 struct elf_i386_link_hash_entry
*eh
;
2336 struct elf_dyn_relocs
*p
;
2337 unsigned plt_entry_size
;
2339 if (h
->root
.type
== bfd_link_hash_indirect
)
2342 eh
= (struct elf_i386_link_hash_entry
*) h
;
2344 info
= (struct bfd_link_info
*) inf
;
2345 htab
= elf_i386_hash_table (info
);
2349 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2351 /* Clear the reference count of function pointer relocations if
2352 symbol isn't a normal function. */
2353 if (h
->type
!= STT_FUNC
)
2354 eh
->func_pointer_refcount
= 0;
2356 /* We can't use the GOT PLT if pointer equality is needed since
2357 finish_dynamic_symbol won't clear symbol value and the dynamic
2358 linker won't update the GOT slot. We will get into an infinite
2359 loop at run-time. */
2360 if (htab
->plt_got
!= NULL
2361 && h
->type
!= STT_GNU_IFUNC
2362 && !h
->pointer_equality_needed
2363 && h
->plt
.refcount
> 0
2364 && h
->got
.refcount
> 0)
2366 /* Don't use the regular PLT if there are both GOT and GOTPLT
2368 h
->plt
.offset
= (bfd_vma
) -1;
2370 /* Use the GOT PLT. */
2371 eh
->plt_got
.refcount
= 1;
2374 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2375 here if it is defined and referenced in a non-shared object. */
2376 if (h
->type
== STT_GNU_IFUNC
2378 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2381 /* Don't create the PLT entry if there are only function pointer
2382 relocations which can be resolved at run-time. */
2383 else if (htab
->elf
.dynamic_sections_created
2384 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2385 || eh
->plt_got
.refcount
> 0))
2387 bfd_boolean use_plt_got
;
2389 /* Clear the reference count of function pointer relocations
2391 eh
->func_pointer_refcount
= 0;
2393 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2395 /* Don't use the regular PLT for DF_BIND_NOW. */
2396 h
->plt
.offset
= (bfd_vma
) -1;
2398 /* Use the GOT PLT. */
2399 h
->got
.refcount
= 1;
2400 eh
->plt_got
.refcount
= 1;
2403 use_plt_got
= eh
->plt_got
.refcount
> 0;
2405 /* Make sure this symbol is output as a dynamic symbol.
2406 Undefined weak syms won't yet be marked as dynamic. */
2407 if (h
->dynindx
== -1
2408 && !h
->forced_local
)
2410 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2414 if (bfd_link_pic (info
)
2415 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2417 asection
*s
= htab
->elf
.splt
;
2418 asection
*got_s
= htab
->plt_got
;
2420 /* If this is the first .plt entry, make room for the special
2421 first entry. The .plt section is used by prelink to undo
2422 prelinking for dynamic relocations. */
2424 s
->size
= plt_entry_size
;
2427 eh
->plt_got
.offset
= got_s
->size
;
2429 h
->plt
.offset
= s
->size
;
2431 /* If this symbol is not defined in a regular file, and we are
2432 not generating a shared library, then set the symbol to this
2433 location in the .plt. This is required to make function
2434 pointers compare as equal between the normal executable and
2435 the shared library. */
2436 if (! bfd_link_pic (info
)
2441 /* We need to make a call to the entry of the GOT PLT
2442 instead of regular PLT entry. */
2443 h
->root
.u
.def
.section
= got_s
;
2444 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2448 h
->root
.u
.def
.section
= s
;
2449 h
->root
.u
.def
.value
= h
->plt
.offset
;
2453 /* Make room for this entry. */
2455 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2458 s
->size
+= plt_entry_size
;
2460 /* We also need to make an entry in the .got.plt section,
2461 which will be placed in the .got section by the linker
2463 htab
->elf
.sgotplt
->size
+= 4;
2465 /* We also need to make an entry in the .rel.plt section. */
2466 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2467 htab
->elf
.srelplt
->reloc_count
++;
2470 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2471 && !bfd_link_pic (info
))
2473 /* VxWorks has a second set of relocations for each PLT entry
2474 in executables. They go in a separate relocation section,
2475 which is processed by the kernel loader. */
2477 /* There are two relocations for the initial PLT entry: an
2478 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2479 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2481 if (h
->plt
.offset
== plt_entry_size
)
2482 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2484 /* There are two extra relocations for each subsequent PLT entry:
2485 an R_386_32 relocation for the GOT entry, and an R_386_32
2486 relocation for the PLT entry. */
2488 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2493 h
->plt
.offset
= (bfd_vma
) -1;
2499 h
->plt
.offset
= (bfd_vma
) -1;
2503 eh
->tlsdesc_got
= (bfd_vma
) -1;
2505 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2506 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2507 if (h
->got
.refcount
> 0
2508 && bfd_link_executable (info
)
2510 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2511 h
->got
.offset
= (bfd_vma
) -1;
2512 else if (h
->got
.refcount
> 0)
2516 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2518 /* Make sure this symbol is output as a dynamic symbol.
2519 Undefined weak syms won't yet be marked as dynamic. */
2520 if (h
->dynindx
== -1
2521 && !h
->forced_local
)
2523 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2528 if (GOT_TLS_GDESC_P (tls_type
))
2530 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2531 - elf_i386_compute_jump_table_size (htab
);
2532 htab
->elf
.sgotplt
->size
+= 8;
2533 h
->got
.offset
= (bfd_vma
) -2;
2535 if (! GOT_TLS_GDESC_P (tls_type
)
2536 || GOT_TLS_GD_P (tls_type
))
2538 h
->got
.offset
= s
->size
;
2540 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2541 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2544 dyn
= htab
->elf
.dynamic_sections_created
;
2545 /* R_386_TLS_IE_32 needs one dynamic relocation,
2546 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2547 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2548 need two), R_386_TLS_GD needs one if local symbol and two if
2550 if (tls_type
== GOT_TLS_IE_BOTH
)
2551 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2552 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2553 || (tls_type
& GOT_TLS_IE
))
2554 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2555 else if (GOT_TLS_GD_P (tls_type
))
2556 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2557 else if (! GOT_TLS_GDESC_P (tls_type
)
2558 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2559 || h
->root
.type
!= bfd_link_hash_undefweak
)
2560 && (bfd_link_pic (info
)
2561 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2562 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2563 if (GOT_TLS_GDESC_P (tls_type
))
2564 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2567 h
->got
.offset
= (bfd_vma
) -1;
2569 if (eh
->dyn_relocs
== NULL
)
2572 /* In the shared -Bsymbolic case, discard space allocated for
2573 dynamic pc-relative relocs against symbols which turn out to be
2574 defined in regular objects. For the normal shared case, discard
2575 space for pc-relative relocs that have become local due to symbol
2576 visibility changes. */
2578 if (bfd_link_pic (info
))
2580 /* The only reloc that uses pc_count is R_386_PC32, which will
2581 appear on a call or on something like ".long foo - .". We
2582 want calls to protected symbols to resolve directly to the
2583 function rather than going via the plt. If people want
2584 function pointer comparisons to work as expected then they
2585 should avoid writing assembly like ".long foo - .". */
2586 if (SYMBOL_CALLS_LOCAL (info
, h
))
2588 struct elf_dyn_relocs
**pp
;
2590 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2592 p
->count
-= p
->pc_count
;
2601 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2603 struct elf_dyn_relocs
**pp
;
2604 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2606 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2613 /* Also discard relocs on undefined weak syms with non-default
2615 if (eh
->dyn_relocs
!= NULL
2616 && h
->root
.type
== bfd_link_hash_undefweak
)
2618 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2619 eh
->dyn_relocs
= NULL
;
2621 /* Make sure undefined weak symbols are output as a dynamic
2623 else if (h
->dynindx
== -1
2624 && !h
->forced_local
)
2626 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2631 else if (ELIMINATE_COPY_RELOCS
)
2633 /* For the non-shared case, discard space for relocs against
2634 symbols which turn out to need copy relocs or are not
2635 dynamic. Keep dynamic relocations for run-time function
2636 pointer initialization. */
2638 if ((!h
->non_got_ref
|| eh
->func_pointer_refcount
> 0)
2641 || (htab
->elf
.dynamic_sections_created
2642 && (h
->root
.type
== bfd_link_hash_undefweak
2643 || h
->root
.type
== bfd_link_hash_undefined
))))
2645 /* Make sure this symbol is output as a dynamic symbol.
2646 Undefined weak syms won't yet be marked as dynamic. */
2647 if (h
->dynindx
== -1
2648 && !h
->forced_local
)
2650 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2654 /* If that succeeded, we know we'll be keeping all the
2656 if (h
->dynindx
!= -1)
2660 eh
->dyn_relocs
= NULL
;
2661 eh
->func_pointer_refcount
= 0;
2666 /* Finally, allocate space. */
2667 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2671 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2673 BFD_ASSERT (sreloc
!= NULL
);
2674 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2680 /* Allocate space in .plt, .got and associated reloc sections for
2681 local dynamic relocs. */
2684 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2686 struct elf_link_hash_entry
*h
2687 = (struct elf_link_hash_entry
*) *slot
;
2689 if (h
->type
!= STT_GNU_IFUNC
2693 || h
->root
.type
!= bfd_link_hash_defined
)
2696 return elf_i386_allocate_dynrelocs (h
, inf
);
2699 /* Find any dynamic relocs that apply to read-only sections. */
2702 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2704 struct elf_i386_link_hash_entry
*eh
;
2705 struct elf_dyn_relocs
*p
;
2707 /* Skip local IFUNC symbols. */
2708 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2711 eh
= (struct elf_i386_link_hash_entry
*) h
;
2712 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2714 asection
*s
= p
->sec
->output_section
;
2716 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2718 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2720 info
->flags
|= DF_TEXTREL
;
2722 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2723 || info
->error_textrel
)
2724 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2725 p
->sec
->owner
, h
->root
.root
.string
,
2728 /* Not an error, just cut short the traversal. */
2735 /* With the local symbol, foo, we convert
2736 mov foo@GOT[(%reg1)], %reg2
2738 lea foo[@GOTOFF(%reg1)], %reg2
2740 call/jmp *foo@GOT[(%reg)]
2742 nop call foo/jmp foo nop
2743 When PIC is false, convert
2744 test %reg1, foo@GOT[(%reg2)]
2748 binop foo@GOT[(%reg1)], %reg2
2751 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2755 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
2756 struct bfd_link_info
*link_info
)
2758 Elf_Internal_Shdr
*symtab_hdr
;
2759 Elf_Internal_Rela
*internal_relocs
;
2760 Elf_Internal_Rela
*irel
, *irelend
;
2762 struct elf_i386_link_hash_table
*htab
;
2763 bfd_boolean changed_contents
;
2764 bfd_boolean changed_relocs
;
2765 bfd_signed_vma
*local_got_refcounts
;
2767 /* Don't even try to convert non-ELF outputs. */
2768 if (!is_elf_hash_table (link_info
->hash
))
2771 /* Nothing to do if there is no need or no output. */
2772 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2773 || sec
->need_convert_load
== 0
2774 || bfd_is_abs_section (sec
->output_section
))
2777 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2779 /* Load the relocations for this section. */
2780 internal_relocs
= (_bfd_elf_link_read_relocs
2781 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2782 link_info
->keep_memory
));
2783 if (internal_relocs
== NULL
)
2786 htab
= elf_i386_hash_table (link_info
);
2787 changed_contents
= FALSE
;
2788 changed_relocs
= FALSE
;
2789 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2791 /* Get the section contents. */
2792 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2793 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2796 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2800 irelend
= internal_relocs
+ sec
->reloc_count
;
2801 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2803 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2804 unsigned int r_symndx
= ELF32_R_SYM (irel
->r_info
);
2806 struct elf_link_hash_entry
*h
;
2807 unsigned int opcode
;
2810 bfd_boolean baseless
;
2811 Elf_Internal_Sym
*isym
;
2812 unsigned int addend
;
2816 if (r_type
!= R_386_GOT32
&& r_type
!= R_386_GOT32X
)
2819 roff
= irel
->r_offset
;
2823 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
2824 addend
= bfd_get_32 (abfd
, contents
+ roff
);
2828 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2829 baseless
= (modrm
& 0xc7) == 0x5;
2831 if (r_type
== R_386_GOT32X
2833 && bfd_link_pic (link_info
))
2835 /* For PIC, disallow R_386_GOT32X without a base register
2836 since we don't know what the GOT base is. Allow
2837 R_386_GOT32 for existing object files. */
2840 if (r_symndx
< symtab_hdr
->sh_info
)
2842 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
2844 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
2848 indx
= r_symndx
- symtab_hdr
->sh_info
;
2849 h
= elf_sym_hashes (abfd
)[indx
];
2850 BFD_ASSERT (h
!= NULL
);
2851 name
= h
->root
.root
.string
;
2854 (*_bfd_error_handler
)
2855 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
2860 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
2862 /* It is OK to convert mov to lea. */
2865 /* Only convert R_386_GOT32X relocation for call, jmp or
2866 one of adc, add, and, cmp, or, sbb, sub, test, xor
2868 if (r_type
!= R_386_GOT32X
)
2871 /* It is OK to convert indirect branch to direct branch. It
2872 is OK to convert adc, add, and, cmp, or, sbb, sub, test,
2873 xor only when PIC is false. */
2874 if (opcode
!= 0xff && bfd_link_pic (link_info
))
2878 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
2879 referred to by the reloc. */
2880 if (r_symndx
< symtab_hdr
->sh_info
)
2882 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2885 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2886 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2890 if (opcode
== 0x0ff)
2891 /* Convert "call/jmp *foo@GOT[(%reg)]". */
2892 goto convert_branch
;
2894 /* Convert "mov foo@GOT[(%reg1)], %reg2",
2895 "test %reg1, foo@GOT(%reg2)" and
2896 "binop foo@GOT[(%reg1)], %reg2". */
2900 indx
= r_symndx
- symtab_hdr
->sh_info
;
2901 h
= elf_sym_hashes (abfd
)[indx
];
2902 BFD_ASSERT (h
!= NULL
);
2904 while (h
->root
.type
== bfd_link_hash_indirect
2905 || h
->root
.type
== bfd_link_hash_warning
)
2906 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2908 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2909 if (h
->type
== STT_GNU_IFUNC
)
2914 /* We have "call/jmp *foo@GOT[(%reg)]". */
2915 if ((h
->root
.type
== bfd_link_hash_defined
2916 || h
->root
.type
== bfd_link_hash_defweak
)
2917 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2919 /* The function is locally defined. */
2921 /* Convert R_386_GOT32X to R_386_PC32. */
2922 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
2924 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2927 nop
= link_info
->call_nop_byte
;
2928 if (link_info
->call_nop_as_suffix
)
2930 nop_offset
= roff
+ 3;
2931 irel
->r_offset
-= 1;
2934 nop_offset
= roff
- 2;
2938 /* Convert to "jmp foo nop". */
2941 nop_offset
= roff
+ 3;
2942 irel
->r_offset
-= 1;
2945 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2946 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2947 /* When converting to PC-relative relocation, we
2948 need to adjust addend by -4. */
2949 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
2950 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
2954 if (h
->got
.refcount
> 0)
2955 h
->got
.refcount
-= 1;
2959 if (local_got_refcounts
!= NULL
2960 && local_got_refcounts
[r_symndx
] > 0)
2961 local_got_refcounts
[r_symndx
] -= 1;
2964 changed_contents
= TRUE
;
2965 changed_relocs
= TRUE
;
2970 /* We have "mov foo@GOT[(%re1g)], %reg2",
2971 "test %reg1, foo@GOT(%reg2)" and
2972 "binop foo@GOT[(%reg1)], %reg2".
2974 Avoid optimizing _DYNAMIC since ld.so may use its
2975 link-time address. */
2976 if (h
== htab
->elf
.hdynamic
)
2979 /* def_regular is set by an assignment in a linker script in
2980 bfd_elf_record_link_assignment. */
2982 || h
->root
.type
== bfd_link_hash_defined
2983 || h
->root
.type
== bfd_link_hash_defweak
)
2984 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2989 /* Convert "mov foo@GOT(%reg1), %reg2" to
2990 "lea foo@GOTOFF(%reg1), %reg2". */
2991 if (r_type
== R_386_GOT32X
2992 && (baseless
|| !bfd_link_pic (link_info
)))
2995 /* For R_386_32, convert
2996 "lea foo@GOTOFF(%reg1), %reg2" to
2997 "lea foo@GOT, %reg2". */
3000 modrm
= 0x5 | (modrm
& 0x38);
3001 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3005 r_type
= R_386_GOTOFF
;
3012 /* Convert "test %reg1, foo@GOT(%reg2)" to
3013 "test $foo, %reg1". */
3014 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3019 /* Convert "binop foo@GOT(%reg1), %reg2" to
3020 "binop $foo, %reg2". */
3022 | (modrm
& 0x38) >> 3
3026 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3030 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3031 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3035 if (h
->got
.refcount
> 0)
3036 h
->got
.refcount
-= 1;
3040 if (local_got_refcounts
!= NULL
3041 && local_got_refcounts
[r_symndx
] > 0)
3042 local_got_refcounts
[r_symndx
] -= 1;
3045 changed_contents
= TRUE
;
3046 changed_relocs
= TRUE
;
3051 if (contents
!= NULL
3052 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3054 if (!changed_contents
&& !link_info
->keep_memory
)
3058 /* Cache the section contents for elf_link_input_bfd. */
3059 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3063 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3065 if (!changed_relocs
)
3066 free (internal_relocs
);
3068 elf_section_data (sec
)->relocs
= internal_relocs
;
3074 if (contents
!= NULL
3075 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3077 if (internal_relocs
!= NULL
3078 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3079 free (internal_relocs
);
3083 /* Set the sizes of the dynamic sections. */
3086 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3088 struct elf_i386_link_hash_table
*htab
;
3094 htab
= elf_i386_hash_table (info
);
3097 dynobj
= htab
->elf
.dynobj
;
3101 if (htab
->elf
.dynamic_sections_created
)
3103 /* Set the contents of the .interp section to the interpreter. */
3104 if (bfd_link_executable (info
) && !info
->nointerp
)
3106 s
= bfd_get_linker_section (dynobj
, ".interp");
3109 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3110 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3114 /* Set up .got offsets for local syms, and space for local dynamic
3116 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3118 bfd_signed_vma
*local_got
;
3119 bfd_signed_vma
*end_local_got
;
3120 char *local_tls_type
;
3121 bfd_vma
*local_tlsdesc_gotent
;
3122 bfd_size_type locsymcount
;
3123 Elf_Internal_Shdr
*symtab_hdr
;
3126 if (! is_i386_elf (ibfd
))
3129 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3131 struct elf_dyn_relocs
*p
;
3133 if (!elf_i386_convert_load (ibfd
, s
, info
))
3136 for (p
= ((struct elf_dyn_relocs
*)
3137 elf_section_data (s
)->local_dynrel
);
3141 if (!bfd_is_abs_section (p
->sec
)
3142 && bfd_is_abs_section (p
->sec
->output_section
))
3144 /* Input section has been discarded, either because
3145 it is a copy of a linkonce section or due to
3146 linker script /DISCARD/, so we'll be discarding
3149 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3150 && strcmp (p
->sec
->output_section
->name
,
3153 /* Relocations in vxworks .tls_vars sections are
3154 handled specially by the loader. */
3156 else if (p
->count
!= 0)
3158 srel
= elf_section_data (p
->sec
)->sreloc
;
3159 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3160 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3161 && (info
->flags
& DF_TEXTREL
) == 0)
3163 info
->flags
|= DF_TEXTREL
;
3164 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3165 || info
->error_textrel
)
3166 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3167 p
->sec
->owner
, p
->sec
);
3173 local_got
= elf_local_got_refcounts (ibfd
);
3177 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3178 locsymcount
= symtab_hdr
->sh_info
;
3179 end_local_got
= local_got
+ locsymcount
;
3180 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3181 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3183 srel
= htab
->elf
.srelgot
;
3184 for (; local_got
< end_local_got
;
3185 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3187 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3190 if (GOT_TLS_GDESC_P (*local_tls_type
))
3192 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3193 - elf_i386_compute_jump_table_size (htab
);
3194 htab
->elf
.sgotplt
->size
+= 8;
3195 *local_got
= (bfd_vma
) -2;
3197 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3198 || GOT_TLS_GD_P (*local_tls_type
))
3200 *local_got
= s
->size
;
3202 if (GOT_TLS_GD_P (*local_tls_type
)
3203 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3206 if (bfd_link_pic (info
)
3207 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3208 || (*local_tls_type
& GOT_TLS_IE
))
3210 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3211 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3212 else if (GOT_TLS_GD_P (*local_tls_type
)
3213 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3214 srel
->size
+= sizeof (Elf32_External_Rel
);
3215 if (GOT_TLS_GDESC_P (*local_tls_type
))
3216 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3220 *local_got
= (bfd_vma
) -1;
3224 if (htab
->tls_ldm_got
.refcount
> 0)
3226 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3228 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3229 htab
->elf
.sgot
->size
+= 8;
3230 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3233 htab
->tls_ldm_got
.offset
= -1;
3235 /* Allocate global sym .plt and .got entries, and space for global
3236 sym dynamic relocs. */
3237 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3239 /* Allocate .plt and .got entries, and space for local symbols. */
3240 htab_traverse (htab
->loc_hash_table
,
3241 elf_i386_allocate_local_dynrelocs
,
3244 /* For every jump slot reserved in the sgotplt, reloc_count is
3245 incremented. However, when we reserve space for TLS descriptors,
3246 it's not incremented, so in order to compute the space reserved
3247 for them, it suffices to multiply the reloc count by the jump
3250 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3251 so that R_386_IRELATIVE entries come last. */
3252 if (htab
->elf
.srelplt
)
3254 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3255 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3256 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3258 else if (htab
->elf
.irelplt
)
3259 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3262 if (htab
->elf
.sgotplt
)
3264 /* Don't allocate .got.plt section if there are no GOT nor PLT
3265 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3266 if ((htab
->elf
.hgot
== NULL
3267 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3268 && (htab
->elf
.sgotplt
->size
3269 == get_elf_backend_data (output_bfd
)->got_header_size
)
3270 && (htab
->elf
.splt
== NULL
3271 || htab
->elf
.splt
->size
== 0)
3272 && (htab
->elf
.sgot
== NULL
3273 || htab
->elf
.sgot
->size
== 0)
3274 && (htab
->elf
.iplt
== NULL
3275 || htab
->elf
.iplt
->size
== 0)
3276 && (htab
->elf
.igotplt
== NULL
3277 || htab
->elf
.igotplt
->size
== 0))
3278 htab
->elf
.sgotplt
->size
= 0;
3282 if (htab
->plt_eh_frame
!= NULL
3283 && htab
->elf
.splt
!= NULL
3284 && htab
->elf
.splt
->size
!= 0
3285 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3286 && _bfd_elf_eh_frame_present (info
))
3287 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3289 /* We now have determined the sizes of the various dynamic sections.
3290 Allocate memory for them. */
3292 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3294 bfd_boolean strip_section
= TRUE
;
3296 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3299 if (s
== htab
->elf
.splt
3300 || s
== htab
->elf
.sgot
)
3302 /* Strip this section if we don't need it; see the
3304 /* We'd like to strip these sections if they aren't needed, but if
3305 we've exported dynamic symbols from them we must leave them.
3306 It's too late to tell BFD to get rid of the symbols. */
3308 if (htab
->elf
.hplt
!= NULL
)
3309 strip_section
= FALSE
;
3311 else if (s
== htab
->elf
.sgotplt
3312 || s
== htab
->elf
.iplt
3313 || s
== htab
->elf
.igotplt
3314 || s
== htab
->plt_got
3315 || s
== htab
->plt_eh_frame
3316 || s
== htab
->sdynbss
)
3318 /* Strip these too. */
3320 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3323 && s
!= htab
->elf
.srelplt
3324 && s
!= htab
->srelplt2
)
3327 /* We use the reloc_count field as a counter if we need
3328 to copy relocs into the output file. */
3333 /* It's not one of our sections, so don't allocate space. */
3339 /* If we don't need this section, strip it from the
3340 output file. This is mostly to handle .rel.bss and
3341 .rel.plt. We must create both sections in
3342 create_dynamic_sections, because they must be created
3343 before the linker maps input sections to output
3344 sections. The linker does that before
3345 adjust_dynamic_symbol is called, and it is that
3346 function which decides whether anything needs to go
3347 into these sections. */
3349 s
->flags
|= SEC_EXCLUDE
;
3353 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3356 /* Allocate memory for the section contents. We use bfd_zalloc
3357 here in case unused entries are not reclaimed before the
3358 section's contents are written out. This should not happen,
3359 but this way if it does, we get a R_386_NONE reloc instead
3361 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3362 if (s
->contents
== NULL
)
3366 if (htab
->plt_eh_frame
!= NULL
3367 && htab
->plt_eh_frame
->contents
!= NULL
)
3369 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3370 sizeof (elf_i386_eh_frame_plt
));
3371 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3372 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3375 if (htab
->elf
.dynamic_sections_created
)
3377 /* Add some entries to the .dynamic section. We fill in the
3378 values later, in elf_i386_finish_dynamic_sections, but we
3379 must add the entries now so that we get the correct size for
3380 the .dynamic section. The DT_DEBUG entry is filled in by the
3381 dynamic linker and used by the debugger. */
3382 #define add_dynamic_entry(TAG, VAL) \
3383 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3385 if (bfd_link_executable (info
))
3387 if (!add_dynamic_entry (DT_DEBUG
, 0))
3391 if (htab
->elf
.splt
->size
!= 0)
3393 /* DT_PLTGOT is used by prelink even if there is no PLT
3395 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3398 if (htab
->elf
.srelplt
->size
!= 0)
3400 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3401 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3402 || !add_dynamic_entry (DT_JMPREL
, 0))
3409 if (!add_dynamic_entry (DT_REL
, 0)
3410 || !add_dynamic_entry (DT_RELSZ
, 0)
3411 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3414 /* If any dynamic relocs apply to a read-only section,
3415 then we need a DT_TEXTREL entry. */
3416 if ((info
->flags
& DF_TEXTREL
) == 0)
3417 elf_link_hash_traverse (&htab
->elf
,
3418 elf_i386_readonly_dynrelocs
, info
);
3420 if ((info
->flags
& DF_TEXTREL
) != 0)
3422 if ((elf_tdata (output_bfd
)->has_gnu_symbols
3423 & elf_gnu_symbol_ifunc
) == elf_gnu_symbol_ifunc
)
3425 info
->callbacks
->einfo
3426 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3427 bfd_set_error (bfd_error_bad_value
);
3431 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3435 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3436 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3439 #undef add_dynamic_entry
3445 elf_i386_always_size_sections (bfd
*output_bfd
,
3446 struct bfd_link_info
*info
)
3448 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3452 struct elf_link_hash_entry
*tlsbase
;
3454 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3455 "_TLS_MODULE_BASE_",
3456 FALSE
, FALSE
, FALSE
);
3458 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3460 struct elf_i386_link_hash_table
*htab
;
3461 struct bfd_link_hash_entry
*bh
= NULL
;
3462 const struct elf_backend_data
*bed
3463 = get_elf_backend_data (output_bfd
);
3465 htab
= elf_i386_hash_table (info
);
3469 if (!(_bfd_generic_link_add_one_symbol
3470 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3471 tls_sec
, 0, NULL
, FALSE
,
3472 bed
->collect
, &bh
)))
3475 htab
->tls_module_base
= bh
;
3477 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3478 tlsbase
->def_regular
= 1;
3479 tlsbase
->other
= STV_HIDDEN
;
3480 tlsbase
->root
.linker_def
= 1;
3481 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3488 /* Set the correct type for an x86 ELF section. We do this by the
3489 section name, which is a hack, but ought to work. */
3492 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3493 Elf_Internal_Shdr
*hdr
,
3498 name
= bfd_get_section_name (abfd
, sec
);
3500 /* This is an ugly, but unfortunately necessary hack that is
3501 needed when producing EFI binaries on x86. It tells
3502 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3503 containing ELF relocation info. We need this hack in order to
3504 be able to generate ELF binaries that can be translated into
3505 EFI applications (which are essentially COFF objects). Those
3506 files contain a COFF ".reloc" section inside an ELFNN object,
3507 which would normally cause BFD to segfault because it would
3508 attempt to interpret this section as containing relocation
3509 entries for section "oc". With this hack enabled, ".reloc"
3510 will be treated as a normal data section, which will avoid the
3511 segfault. However, you won't be able to create an ELFNN binary
3512 with a section named "oc" that needs relocations, but that's
3513 the kind of ugly side-effects you get when detecting section
3514 types based on their names... In practice, this limitation is
3515 unlikely to bite. */
3516 if (strcmp (name
, ".reloc") == 0)
3517 hdr
->sh_type
= SHT_PROGBITS
;
3522 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3523 executables. Rather than setting it to the beginning of the TLS
3524 section, we have to set it to the end. This function may be called
3525 multiple times, it is idempotent. */
3528 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3530 struct elf_i386_link_hash_table
*htab
;
3531 struct bfd_link_hash_entry
*base
;
3533 if (!bfd_link_executable (info
))
3536 htab
= elf_i386_hash_table (info
);
3540 base
= htab
->tls_module_base
;
3544 base
->u
.def
.value
= htab
->elf
.tls_size
;
3547 /* Return the base VMA address which should be subtracted from real addresses
3548 when resolving @dtpoff relocation.
3549 This is PT_TLS segment p_vaddr. */
3552 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3554 /* If tls_sec is NULL, we should have signalled an error already. */
3555 if (elf_hash_table (info
)->tls_sec
== NULL
)
3557 return elf_hash_table (info
)->tls_sec
->vma
;
3560 /* Return the relocation value for @tpoff relocation
3561 if STT_TLS virtual address is ADDRESS. */
3564 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3566 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3567 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3568 bfd_vma static_tls_size
;
3570 /* If tls_sec is NULL, we should have signalled an error already. */
3571 if (htab
->tls_sec
== NULL
)
3574 /* Consider special static TLS alignment requirements. */
3575 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3576 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3579 /* Relocate an i386 ELF section. */
3582 elf_i386_relocate_section (bfd
*output_bfd
,
3583 struct bfd_link_info
*info
,
3585 asection
*input_section
,
3587 Elf_Internal_Rela
*relocs
,
3588 Elf_Internal_Sym
*local_syms
,
3589 asection
**local_sections
)
3591 struct elf_i386_link_hash_table
*htab
;
3592 Elf_Internal_Shdr
*symtab_hdr
;
3593 struct elf_link_hash_entry
**sym_hashes
;
3594 bfd_vma
*local_got_offsets
;
3595 bfd_vma
*local_tlsdesc_gotents
;
3596 Elf_Internal_Rela
*rel
;
3597 Elf_Internal_Rela
*wrel
;
3598 Elf_Internal_Rela
*relend
;
3599 bfd_boolean is_vxworks_tls
;
3600 unsigned plt_entry_size
;
3602 BFD_ASSERT (is_i386_elf (input_bfd
));
3604 htab
= elf_i386_hash_table (info
);
3607 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3608 sym_hashes
= elf_sym_hashes (input_bfd
);
3609 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3610 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3611 /* We have to handle relocations in vxworks .tls_vars sections
3612 specially, because the dynamic loader is 'weird'. */
3613 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3614 && bfd_link_pic (info
)
3615 && !strcmp (input_section
->output_section
->name
,
3618 elf_i386_set_tls_module_base (info
);
3620 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3622 rel
= wrel
= relocs
;
3623 relend
= relocs
+ input_section
->reloc_count
;
3624 for (; rel
< relend
; wrel
++, rel
++)
3626 unsigned int r_type
;
3627 reloc_howto_type
*howto
;
3628 unsigned long r_symndx
;
3629 struct elf_link_hash_entry
*h
;
3630 struct elf_i386_link_hash_entry
*eh
;
3631 Elf_Internal_Sym
*sym
;
3633 bfd_vma off
, offplt
, plt_offset
;
3635 bfd_boolean unresolved_reloc
;
3636 bfd_reloc_status_type r
;
3640 asection
*resolved_plt
;
3642 r_type
= ELF32_R_TYPE (rel
->r_info
);
3643 if (r_type
== R_386_GNU_VTINHERIT
3644 || r_type
== R_386_GNU_VTENTRY
)
3651 if ((indx
= r_type
) >= R_386_standard
3652 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3653 >= R_386_ext
- R_386_standard
)
3654 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3655 >= R_386_ext2
- R_386_ext
))
3657 (*_bfd_error_handler
)
3658 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3659 input_bfd
, input_section
, r_type
);
3660 bfd_set_error (bfd_error_bad_value
);
3663 howto
= elf_howto_table
+ indx
;
3665 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3669 unresolved_reloc
= FALSE
;
3670 if (r_symndx
< symtab_hdr
->sh_info
)
3672 sym
= local_syms
+ r_symndx
;
3673 sec
= local_sections
[r_symndx
];
3674 relocation
= (sec
->output_section
->vma
3675 + sec
->output_offset
3677 st_size
= sym
->st_size
;
3679 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3680 && ((sec
->flags
& SEC_MERGE
) != 0
3681 || (bfd_link_relocatable (info
)
3682 && sec
->output_offset
!= 0)))
3685 bfd_byte
*where
= contents
+ rel
->r_offset
;
3687 switch (howto
->size
)
3690 addend
= bfd_get_8 (input_bfd
, where
);
3691 if (howto
->pc_relative
)
3693 addend
= (addend
^ 0x80) - 0x80;
3698 addend
= bfd_get_16 (input_bfd
, where
);
3699 if (howto
->pc_relative
)
3701 addend
= (addend
^ 0x8000) - 0x8000;
3706 addend
= bfd_get_32 (input_bfd
, where
);
3707 if (howto
->pc_relative
)
3709 addend
= (addend
^ 0x80000000) - 0x80000000;
3717 if (bfd_link_relocatable (info
))
3718 addend
+= sec
->output_offset
;
3721 asection
*msec
= sec
;
3722 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3724 addend
-= relocation
;
3725 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3728 switch (howto
->size
)
3731 /* FIXME: overflow checks. */
3732 if (howto
->pc_relative
)
3734 bfd_put_8 (input_bfd
, addend
, where
);
3737 if (howto
->pc_relative
)
3739 bfd_put_16 (input_bfd
, addend
, where
);
3742 if (howto
->pc_relative
)
3744 bfd_put_32 (input_bfd
, addend
, where
);
3748 else if (!bfd_link_relocatable (info
)
3749 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3751 /* Relocate against local STT_GNU_IFUNC symbol. */
3752 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3757 /* Set STT_GNU_IFUNC symbol value. */
3758 h
->root
.u
.def
.value
= sym
->st_value
;
3759 h
->root
.u
.def
.section
= sec
;
3764 bfd_boolean warned ATTRIBUTE_UNUSED
;
3765 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3767 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3768 r_symndx
, symtab_hdr
, sym_hashes
,
3770 unresolved_reloc
, warned
, ignored
);
3774 if (sec
!= NULL
&& discarded_section (sec
))
3776 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3777 contents
+ rel
->r_offset
);
3778 wrel
->r_offset
= rel
->r_offset
;
3782 /* For ld -r, remove relocations in debug sections against
3783 sections defined in discarded sections. Not done for
3784 eh_frame editing code expects to be present. */
3785 if (bfd_link_relocatable (info
)
3786 && (input_section
->flags
& SEC_DEBUGGING
))
3792 if (bfd_link_relocatable (info
))
3799 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3800 it here if it is defined in a non-shared object. */
3802 && h
->type
== STT_GNU_IFUNC
3805 asection
*plt
, *gotplt
, *base_got
;
3809 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3811 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3812 sections because such sections are not SEC_ALLOC and
3813 thus ld.so will not process them. */
3814 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3818 else if (h
->plt
.offset
== (bfd_vma
) -1)
3821 /* STT_GNU_IFUNC symbol must go through PLT. */
3822 if (htab
->elf
.splt
!= NULL
)
3824 plt
= htab
->elf
.splt
;
3825 gotplt
= htab
->elf
.sgotplt
;
3829 plt
= htab
->elf
.iplt
;
3830 gotplt
= htab
->elf
.igotplt
;
3833 relocation
= (plt
->output_section
->vma
3834 + plt
->output_offset
+ h
->plt
.offset
);
3839 if (h
->root
.root
.string
)
3840 name
= h
->root
.root
.string
;
3842 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3844 (*_bfd_error_handler
)
3845 (_("%B: relocation %s against STT_GNU_IFUNC "
3846 "symbol `%s' isn't handled by %s"), input_bfd
,
3847 elf_howto_table
[r_type
].name
,
3848 name
, __FUNCTION__
);
3849 bfd_set_error (bfd_error_bad_value
);
3853 /* Generate dynamic relcoation only when there is a
3854 non-GOT reference in a shared object. */
3855 if (bfd_link_pic (info
) && h
->non_got_ref
)
3857 Elf_Internal_Rela outrel
;
3861 /* Need a dynamic relocation to get the real function
3863 offset
= _bfd_elf_section_offset (output_bfd
,
3867 if (offset
== (bfd_vma
) -1
3868 || offset
== (bfd_vma
) -2)
3871 outrel
.r_offset
= (input_section
->output_section
->vma
3872 + input_section
->output_offset
3875 if (h
->dynindx
== -1
3877 || bfd_link_executable (info
))
3879 /* This symbol is resolved locally. */
3880 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3881 bfd_put_32 (output_bfd
,
3882 (h
->root
.u
.def
.value
3883 + h
->root
.u
.def
.section
->output_section
->vma
3884 + h
->root
.u
.def
.section
->output_offset
),
3888 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3890 sreloc
= htab
->elf
.irelifunc
;
3891 elf_append_rel (output_bfd
, sreloc
, &outrel
);
3893 /* If this reloc is against an external symbol, we
3894 do not want to fiddle with the addend. Otherwise,
3895 we need to include the symbol value so that it
3896 becomes an addend for the dynamic reloc. For an
3897 internal symbol, we have updated addend. */
3907 base_got
= htab
->elf
.sgot
;
3908 off
= h
->got
.offset
;
3910 if (base_got
== NULL
)
3913 if (off
== (bfd_vma
) -1)
3915 /* We can't use h->got.offset here to save state, or
3916 even just remember the offset, as finish_dynamic_symbol
3917 would use that as offset into .got. */
3919 if (htab
->elf
.splt
!= NULL
)
3921 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3922 off
= (plt_index
+ 3) * 4;
3923 base_got
= htab
->elf
.sgotplt
;
3927 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3928 off
= plt_index
* 4;
3929 base_got
= htab
->elf
.igotplt
;
3932 if (h
->dynindx
== -1
3936 /* This references the local defitionion. We must
3937 initialize this entry in the global offset table.
3938 Since the offset must always be a multiple of 8,
3939 we use the least significant bit to record
3940 whether we have initialized it already.
3942 When doing a dynamic link, we create a .rela.got
3943 relocation entry to initialize the value. This
3944 is done in the finish_dynamic_symbol routine. */
3949 bfd_put_32 (output_bfd
, relocation
,
3950 base_got
->contents
+ off
);
3957 /* Adjust for static executables. */
3958 if (htab
->elf
.splt
== NULL
)
3959 relocation
+= gotplt
->output_offset
;
3963 relocation
= (base_got
->output_section
->vma
3964 + base_got
->output_offset
+ off
3965 - gotplt
->output_section
->vma
3966 - gotplt
->output_offset
);
3967 /* Adjust for static executables. */
3968 if (htab
->elf
.splt
== NULL
)
3969 relocation
+= gotplt
->output_offset
;
3975 relocation
-= (gotplt
->output_section
->vma
3976 + gotplt
->output_offset
);
3981 eh
= (struct elf_i386_link_hash_entry
*) h
;
3985 /* Avoid optimizing _DYNAMIC since ld.so may use its
3986 link-time address. */
3987 if (h
== htab
->elf
.hdynamic
)
3990 if (bfd_link_pic (info
))
3992 /* It is OK to convert mov to lea and convert indirect
3993 branch to direct branch. It is OK to convert adc,
3994 add, and, cmp, or, sbb, sub, test, xor only when PIC
3996 unsigned int opcode
, addend
;
3997 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4000 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4001 if (opcode
!= 0x8b && opcode
!= 0xff)
4005 /* Resolve "mov GOT[(%reg)], %reg",
4006 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4007 and "binop foo@GOT[(%reg)], %reg". */
4009 || (h
->plt
.offset
== (bfd_vma
) -1
4010 && h
->got
.offset
== (bfd_vma
) -1)
4011 || htab
->elf
.sgotplt
== NULL
)
4014 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4015 + htab
->elf
.sgotplt
->output_offset
);
4017 /* It is relative to .got.plt section. */
4018 if (h
->got
.offset
!= (bfd_vma
) -1)
4019 /* Use GOT entry. Mask off the least significant bit in
4020 GOT offset which may be set by R_386_GOT32 processing
4022 relocation
= (htab
->elf
.sgot
->output_section
->vma
4023 + htab
->elf
.sgot
->output_offset
4024 + (h
->got
.offset
& ~1) - offplt
);
4026 /* Use GOTPLT entry. */
4027 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4029 if (!bfd_link_pic (info
))
4031 /* If not PIC, add the .got.plt section address for
4032 baseless addressing. */
4034 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4035 if ((modrm
& 0xc7) == 0x5)
4036 relocation
+= offplt
;
4039 unresolved_reloc
= FALSE
;
4044 /* Relocation is to the entry for this symbol in the global
4046 if (htab
->elf
.sgot
== NULL
)
4053 off
= h
->got
.offset
;
4054 dyn
= htab
->elf
.dynamic_sections_created
;
4055 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4056 bfd_link_pic (info
),
4058 || (bfd_link_pic (info
)
4059 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4060 || (ELF_ST_VISIBILITY (h
->other
)
4061 && h
->root
.type
== bfd_link_hash_undefweak
))
4063 /* This is actually a static link, or it is a
4064 -Bsymbolic link and the symbol is defined
4065 locally, or the symbol was forced to be local
4066 because of a version file. We must initialize
4067 this entry in the global offset table. Since the
4068 offset must always be a multiple of 4, we use the
4069 least significant bit to record whether we have
4070 initialized it already.
4072 When doing a dynamic link, we create a .rel.got
4073 relocation entry to initialize the value. This
4074 is done in the finish_dynamic_symbol routine. */
4079 bfd_put_32 (output_bfd
, relocation
,
4080 htab
->elf
.sgot
->contents
+ off
);
4085 unresolved_reloc
= FALSE
;
4089 if (local_got_offsets
== NULL
)
4092 off
= local_got_offsets
[r_symndx
];
4094 /* The offset must always be a multiple of 4. We use
4095 the least significant bit to record whether we have
4096 already generated the necessary reloc. */
4101 bfd_put_32 (output_bfd
, relocation
,
4102 htab
->elf
.sgot
->contents
+ off
);
4104 if (bfd_link_pic (info
))
4107 Elf_Internal_Rela outrel
;
4109 s
= htab
->elf
.srelgot
;
4113 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4114 + htab
->elf
.sgot
->output_offset
4116 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4117 elf_append_rel (output_bfd
, s
, &outrel
);
4120 local_got_offsets
[r_symndx
] |= 1;
4124 if (off
>= (bfd_vma
) -2)
4127 relocation
= htab
->elf
.sgot
->output_section
->vma
4128 + htab
->elf
.sgot
->output_offset
+ off
4129 - htab
->elf
.sgotplt
->output_section
->vma
4130 - htab
->elf
.sgotplt
->output_offset
;
4134 /* Relocation is relative to the start of the global offset
4137 /* Check to make sure it isn't a protected function or data
4138 symbol for shared library since it may not be local when
4139 used as function address or with copy relocation. We also
4140 need to make sure that a symbol is referenced locally. */
4141 if (!bfd_link_executable (info
) && h
)
4143 if (!h
->def_regular
)
4147 switch (ELF_ST_VISIBILITY (h
->other
))
4150 v
= _("hidden symbol");
4153 v
= _("internal symbol");
4156 v
= _("protected symbol");
4163 (*_bfd_error_handler
)
4164 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4165 input_bfd
, v
, h
->root
.root
.string
);
4166 bfd_set_error (bfd_error_bad_value
);
4169 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4170 && (h
->type
== STT_FUNC
4171 || h
->type
== STT_OBJECT
)
4172 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4174 (*_bfd_error_handler
)
4175 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4177 h
->type
== STT_FUNC
? "function" : "data",
4178 h
->root
.root
.string
);
4179 bfd_set_error (bfd_error_bad_value
);
4184 /* Note that sgot is not involved in this
4185 calculation. We always want the start of .got.plt. If we
4186 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4187 permitted by the ABI, we might have to change this
4189 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4190 + htab
->elf
.sgotplt
->output_offset
;
4194 /* Use global offset table as symbol value. */
4195 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4196 + htab
->elf
.sgotplt
->output_offset
;
4197 unresolved_reloc
= FALSE
;
4201 /* Relocation is to the entry for this symbol in the
4202 procedure linkage table. */
4204 /* Resolve a PLT32 reloc against a local symbol directly,
4205 without using the procedure linkage table. */
4209 if ((h
->plt
.offset
== (bfd_vma
) -1
4210 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4211 || htab
->elf
.splt
== NULL
)
4213 /* We didn't make a PLT entry for this symbol. This
4214 happens when statically linking PIC code, or when
4215 using -Bsymbolic. */
4219 if (h
->plt
.offset
!= (bfd_vma
) -1)
4221 resolved_plt
= htab
->elf
.splt
;
4222 plt_offset
= h
->plt
.offset
;
4226 resolved_plt
= htab
->plt_got
;
4227 plt_offset
= eh
->plt_got
.offset
;
4230 relocation
= (resolved_plt
->output_section
->vma
4231 + resolved_plt
->output_offset
4233 unresolved_reloc
= FALSE
;
4237 /* Set to symbol size. */
4238 relocation
= st_size
;
4243 if ((input_section
->flags
& SEC_ALLOC
) == 0
4247 /* Copy dynamic function pointer relocations. */
4248 if ((bfd_link_pic (info
)
4250 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4251 || h
->root
.type
!= bfd_link_hash_undefweak
)
4252 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4253 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4254 || (ELIMINATE_COPY_RELOCS
4255 && !bfd_link_pic (info
)
4258 && (!h
->non_got_ref
|| eh
->func_pointer_refcount
> 0)
4261 || h
->root
.type
== bfd_link_hash_undefweak
4262 || h
->root
.type
== bfd_link_hash_undefined
)))
4264 Elf_Internal_Rela outrel
;
4265 bfd_boolean skip
, relocate
;
4268 /* When generating a shared object, these relocations
4269 are copied into the output file to be resolved at run
4276 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4278 if (outrel
.r_offset
== (bfd_vma
) -1)
4280 else if (outrel
.r_offset
== (bfd_vma
) -2)
4281 skip
= TRUE
, relocate
= TRUE
;
4282 outrel
.r_offset
+= (input_section
->output_section
->vma
4283 + input_section
->output_offset
);
4286 memset (&outrel
, 0, sizeof outrel
);
4289 && (r_type
== R_386_PC32
4290 || !bfd_link_pic (info
)
4291 || !SYMBOLIC_BIND (info
, h
)
4292 || !h
->def_regular
))
4293 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4296 /* This symbol is local, or marked to become local. */
4298 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4301 sreloc
= elf_section_data (input_section
)->sreloc
;
4303 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4305 r
= bfd_reloc_notsupported
;
4306 goto check_relocation_error
;
4309 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4311 /* If this reloc is against an external symbol, we do
4312 not want to fiddle with the addend. Otherwise, we
4313 need to include the symbol value so that it becomes
4314 an addend for the dynamic reloc. */
4321 if (!bfd_link_executable (info
))
4323 Elf_Internal_Rela outrel
;
4326 outrel
.r_offset
= rel
->r_offset
4327 + input_section
->output_section
->vma
4328 + input_section
->output_offset
;
4329 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4330 sreloc
= elf_section_data (input_section
)->sreloc
;
4333 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4338 case R_386_TLS_GOTDESC
:
4339 case R_386_TLS_DESC_CALL
:
4340 case R_386_TLS_IE_32
:
4341 case R_386_TLS_GOTIE
:
4342 tls_type
= GOT_UNKNOWN
;
4343 if (h
== NULL
&& local_got_offsets
)
4344 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4346 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4347 if (tls_type
== GOT_TLS_IE
)
4348 tls_type
= GOT_TLS_IE_NEG
;
4350 if (! elf_i386_tls_transition (info
, input_bfd
,
4351 input_section
, contents
,
4352 symtab_hdr
, sym_hashes
,
4353 &r_type
, tls_type
, rel
,
4354 relend
, h
, r_symndx
))
4357 if (r_type
== R_386_TLS_LE_32
)
4359 BFD_ASSERT (! unresolved_reloc
);
4360 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4365 /* GD->LE transition. */
4366 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4369 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4371 movl %gs:0, %eax; subl $foo@tpoff, %eax
4372 (6 byte form of subl). */
4373 memcpy (contents
+ rel
->r_offset
- 3,
4374 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4375 roff
= rel
->r_offset
+ 5;
4379 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4381 movl %gs:0, %eax; subl $foo@tpoff, %eax
4382 (6 byte form of subl). */
4383 memcpy (contents
+ rel
->r_offset
- 2,
4384 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4385 roff
= rel
->r_offset
+ 6;
4387 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4389 /* Skip R_386_PC32/R_386_PLT32. */
4394 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4396 /* GDesc -> LE transition.
4397 It's originally something like:
4398 leal x@tlsdesc(%ebx), %eax
4402 Registers other than %eax may be set up here. */
4407 roff
= rel
->r_offset
;
4408 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4410 /* Now modify the instruction as appropriate. */
4411 /* aoliva FIXME: remove the above and xor the byte
4413 bfd_put_8 (output_bfd
, val
^ 0x86,
4414 contents
+ roff
- 1);
4415 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4419 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4421 /* GDesc -> LE transition.
4429 roff
= rel
->r_offset
;
4430 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4431 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4434 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4438 /* IE->LE transition:
4439 Originally it can be one of:
4447 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4450 /* movl foo, %eax. */
4451 bfd_put_8 (output_bfd
, 0xb8,
4452 contents
+ rel
->r_offset
- 1);
4458 type
= bfd_get_8 (input_bfd
,
4459 contents
+ rel
->r_offset
- 2);
4464 bfd_put_8 (output_bfd
, 0xc7,
4465 contents
+ rel
->r_offset
- 2);
4466 bfd_put_8 (output_bfd
,
4467 0xc0 | ((val
>> 3) & 7),
4468 contents
+ rel
->r_offset
- 1);
4472 bfd_put_8 (output_bfd
, 0x81,
4473 contents
+ rel
->r_offset
- 2);
4474 bfd_put_8 (output_bfd
,
4475 0xc0 | ((val
>> 3) & 7),
4476 contents
+ rel
->r_offset
- 1);
4483 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4484 contents
+ rel
->r_offset
);
4489 unsigned int val
, type
;
4491 /* {IE_32,GOTIE}->LE transition:
4492 Originally it can be one of:
4493 subl foo(%reg1), %reg2
4494 movl foo(%reg1), %reg2
4495 addl foo(%reg1), %reg2
4498 movl $foo, %reg2 (6 byte form)
4499 addl $foo, %reg2. */
4500 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4501 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4505 bfd_put_8 (output_bfd
, 0xc7,
4506 contents
+ rel
->r_offset
- 2);
4507 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4508 contents
+ rel
->r_offset
- 1);
4510 else if (type
== 0x2b)
4513 bfd_put_8 (output_bfd
, 0x81,
4514 contents
+ rel
->r_offset
- 2);
4515 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4516 contents
+ rel
->r_offset
- 1);
4518 else if (type
== 0x03)
4521 bfd_put_8 (output_bfd
, 0x81,
4522 contents
+ rel
->r_offset
- 2);
4523 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4524 contents
+ rel
->r_offset
- 1);
4528 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4529 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4530 contents
+ rel
->r_offset
);
4532 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4533 contents
+ rel
->r_offset
);
4538 if (htab
->elf
.sgot
== NULL
)
4543 off
= h
->got
.offset
;
4544 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4548 if (local_got_offsets
== NULL
)
4551 off
= local_got_offsets
[r_symndx
];
4552 offplt
= local_tlsdesc_gotents
[r_symndx
];
4559 Elf_Internal_Rela outrel
;
4563 if (htab
->elf
.srelgot
== NULL
)
4566 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4568 if (GOT_TLS_GDESC_P (tls_type
))
4571 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4572 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4573 <= htab
->elf
.sgotplt
->size
);
4574 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4575 + htab
->elf
.sgotplt
->output_offset
4577 + htab
->sgotplt_jump_table_size
);
4578 sreloc
= htab
->elf
.srelplt
;
4579 loc
= sreloc
->contents
;
4580 loc
+= (htab
->next_tls_desc_index
++
4581 * sizeof (Elf32_External_Rel
));
4582 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4583 <= sreloc
->contents
+ sreloc
->size
);
4584 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4587 BFD_ASSERT (! unresolved_reloc
);
4588 bfd_put_32 (output_bfd
,
4589 relocation
- elf_i386_dtpoff_base (info
),
4590 htab
->elf
.sgotplt
->contents
+ offplt
4591 + htab
->sgotplt_jump_table_size
+ 4);
4595 bfd_put_32 (output_bfd
, 0,
4596 htab
->elf
.sgotplt
->contents
+ offplt
4597 + htab
->sgotplt_jump_table_size
+ 4);
4601 sreloc
= htab
->elf
.srelgot
;
4603 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4604 + htab
->elf
.sgot
->output_offset
+ off
);
4606 if (GOT_TLS_GD_P (tls_type
))
4607 dr_type
= R_386_TLS_DTPMOD32
;
4608 else if (GOT_TLS_GDESC_P (tls_type
))
4610 else if (tls_type
== GOT_TLS_IE_POS
)
4611 dr_type
= R_386_TLS_TPOFF
;
4613 dr_type
= R_386_TLS_TPOFF32
;
4615 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4616 bfd_put_32 (output_bfd
,
4617 relocation
- elf_i386_dtpoff_base (info
),
4618 htab
->elf
.sgot
->contents
+ off
);
4619 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4620 bfd_put_32 (output_bfd
,
4621 elf_i386_dtpoff_base (info
) - relocation
,
4622 htab
->elf
.sgot
->contents
+ off
);
4623 else if (dr_type
!= R_386_TLS_DESC
)
4624 bfd_put_32 (output_bfd
, 0,
4625 htab
->elf
.sgot
->contents
+ off
);
4626 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4628 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4630 if (GOT_TLS_GD_P (tls_type
))
4634 BFD_ASSERT (! unresolved_reloc
);
4635 bfd_put_32 (output_bfd
,
4636 relocation
- elf_i386_dtpoff_base (info
),
4637 htab
->elf
.sgot
->contents
+ off
+ 4);
4641 bfd_put_32 (output_bfd
, 0,
4642 htab
->elf
.sgot
->contents
+ off
+ 4);
4643 outrel
.r_info
= ELF32_R_INFO (indx
,
4644 R_386_TLS_DTPOFF32
);
4645 outrel
.r_offset
+= 4;
4646 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4649 else if (tls_type
== GOT_TLS_IE_BOTH
)
4651 bfd_put_32 (output_bfd
,
4653 ? relocation
- elf_i386_dtpoff_base (info
)
4655 htab
->elf
.sgot
->contents
+ off
+ 4);
4656 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4657 outrel
.r_offset
+= 4;
4658 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4665 local_got_offsets
[r_symndx
] |= 1;
4668 if (off
>= (bfd_vma
) -2
4669 && ! GOT_TLS_GDESC_P (tls_type
))
4671 if (r_type
== R_386_TLS_GOTDESC
4672 || r_type
== R_386_TLS_DESC_CALL
)
4674 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4675 unresolved_reloc
= FALSE
;
4677 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4679 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4680 + htab
->elf
.sgotplt
->output_offset
;
4681 relocation
= htab
->elf
.sgot
->output_section
->vma
4682 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4683 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4684 && tls_type
== GOT_TLS_IE_BOTH
)
4686 if (r_type
== R_386_TLS_IE
)
4687 relocation
+= g_o_t
;
4688 unresolved_reloc
= FALSE
;
4690 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4692 unsigned int val
, type
;
4695 /* GD->IE transition. */
4696 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4697 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4700 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4702 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4704 roff
= rel
->r_offset
- 3;
4708 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4710 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4711 roff
= rel
->r_offset
- 2;
4713 memcpy (contents
+ roff
,
4714 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4715 contents
[roff
+ 7] = 0x80 | (val
& 7);
4716 /* If foo is used only with foo@gotntpoff(%reg) and
4717 foo@indntpoff, but not with foo@gottpoff(%reg), change
4718 subl $foo@gottpoff(%reg), %eax
4720 addl $foo@gotntpoff(%reg), %eax. */
4721 if (tls_type
== GOT_TLS_IE_POS
)
4722 contents
[roff
+ 6] = 0x03;
4723 bfd_put_32 (output_bfd
,
4724 htab
->elf
.sgot
->output_section
->vma
4725 + htab
->elf
.sgot
->output_offset
+ off
4726 - htab
->elf
.sgotplt
->output_section
->vma
4727 - htab
->elf
.sgotplt
->output_offset
,
4728 contents
+ roff
+ 8);
4729 /* Skip R_386_PLT32. */
4734 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4736 /* GDesc -> IE transition.
4737 It's originally something like:
4738 leal x@tlsdesc(%ebx), %eax
4741 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4743 movl x@gottpoff(%ebx), %eax # before negl %eax
4745 Registers other than %eax may be set up here. */
4749 /* First, make sure it's a leal adding ebx to a 32-bit
4750 offset into any register, although it's probably
4751 almost always going to be eax. */
4752 roff
= rel
->r_offset
;
4754 /* Now modify the instruction as appropriate. */
4755 /* To turn a leal into a movl in the form we use it, it
4756 suffices to change the first byte from 0x8d to 0x8b.
4757 aoliva FIXME: should we decide to keep the leal, all
4758 we have to do is remove the statement below, and
4759 adjust the relaxation of R_386_TLS_DESC_CALL. */
4760 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4762 if (tls_type
== GOT_TLS_IE_BOTH
)
4765 bfd_put_32 (output_bfd
,
4766 htab
->elf
.sgot
->output_section
->vma
4767 + htab
->elf
.sgot
->output_offset
+ off
4768 - htab
->elf
.sgotplt
->output_section
->vma
4769 - htab
->elf
.sgotplt
->output_offset
,
4773 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4775 /* GDesc -> IE transition.
4783 depending on how we transformed the TLS_GOTDESC above.
4788 roff
= rel
->r_offset
;
4790 /* Now modify the instruction as appropriate. */
4791 if (tls_type
!= GOT_TLS_IE_NEG
)
4794 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4795 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4800 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
4801 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
4811 if (! elf_i386_tls_transition (info
, input_bfd
,
4812 input_section
, contents
,
4813 symtab_hdr
, sym_hashes
,
4814 &r_type
, GOT_UNKNOWN
, rel
,
4815 relend
, h
, r_symndx
))
4818 if (r_type
!= R_386_TLS_LDM
)
4820 /* LD->LE transition:
4821 leal foo(%reg), %eax; call ___tls_get_addr.
4823 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4824 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
4825 memcpy (contents
+ rel
->r_offset
- 2,
4826 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4827 /* Skip R_386_PC32/R_386_PLT32. */
4833 if (htab
->elf
.sgot
== NULL
)
4836 off
= htab
->tls_ldm_got
.offset
;
4841 Elf_Internal_Rela outrel
;
4843 if (htab
->elf
.srelgot
== NULL
)
4846 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4847 + htab
->elf
.sgot
->output_offset
+ off
);
4849 bfd_put_32 (output_bfd
, 0,
4850 htab
->elf
.sgot
->contents
+ off
);
4851 bfd_put_32 (output_bfd
, 0,
4852 htab
->elf
.sgot
->contents
+ off
+ 4);
4853 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
4854 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
4855 htab
->tls_ldm_got
.offset
|= 1;
4857 relocation
= htab
->elf
.sgot
->output_section
->vma
4858 + htab
->elf
.sgot
->output_offset
+ off
4859 - htab
->elf
.sgotplt
->output_section
->vma
4860 - htab
->elf
.sgotplt
->output_offset
;
4861 unresolved_reloc
= FALSE
;
4864 case R_386_TLS_LDO_32
:
4865 if (!bfd_link_executable (info
)
4866 || (input_section
->flags
& SEC_CODE
) == 0)
4867 relocation
-= elf_i386_dtpoff_base (info
);
4869 /* When converting LDO to LE, we must negate. */
4870 relocation
= -elf_i386_tpoff (info
, relocation
);
4873 case R_386_TLS_LE_32
:
4875 if (!bfd_link_executable (info
))
4877 Elf_Internal_Rela outrel
;
4880 outrel
.r_offset
= rel
->r_offset
4881 + input_section
->output_section
->vma
4882 + input_section
->output_offset
;
4883 if (h
!= NULL
&& h
->dynindx
!= -1)
4887 if (r_type
== R_386_TLS_LE_32
)
4888 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
4890 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4891 sreloc
= elf_section_data (input_section
)->sreloc
;
4894 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4897 else if (r_type
== R_386_TLS_LE_32
)
4898 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
4900 relocation
-= elf_i386_dtpoff_base (info
);
4902 else if (r_type
== R_386_TLS_LE_32
)
4903 relocation
= elf_i386_tpoff (info
, relocation
);
4905 relocation
= -elf_i386_tpoff (info
, relocation
);
4912 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4913 because such sections are not SEC_ALLOC and thus ld.so will
4914 not process them. */
4915 if (unresolved_reloc
4916 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4918 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4919 rel
->r_offset
) != (bfd_vma
) -1)
4921 (*_bfd_error_handler
)
4922 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4925 (long) rel
->r_offset
,
4927 h
->root
.root
.string
);
4932 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4933 contents
, rel
->r_offset
,
4936 check_relocation_error
:
4937 if (r
!= bfd_reloc_ok
)
4942 name
= h
->root
.root
.string
;
4945 name
= bfd_elf_string_from_elf_section (input_bfd
,
4946 symtab_hdr
->sh_link
,
4951 name
= bfd_section_name (input_bfd
, sec
);
4954 if (r
== bfd_reloc_overflow
)
4956 if (! ((*info
->callbacks
->reloc_overflow
)
4957 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4958 (bfd_vma
) 0, input_bfd
, input_section
,
4964 (*_bfd_error_handler
)
4965 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4966 input_bfd
, input_section
,
4967 (long) rel
->r_offset
, name
, (int) r
);
4978 Elf_Internal_Shdr
*rel_hdr
;
4979 size_t deleted
= rel
- wrel
;
4981 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4982 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4983 if (rel_hdr
->sh_size
== 0)
4985 /* It is too late to remove an empty reloc section. Leave
4987 ??? What is wrong with an empty section??? */
4988 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4991 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
4992 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4993 input_section
->reloc_count
-= deleted
;
4999 /* Finish up dynamic symbol handling. We set the contents of various
5000 dynamic sections here. */
5003 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5004 struct bfd_link_info
*info
,
5005 struct elf_link_hash_entry
*h
,
5006 Elf_Internal_Sym
*sym
)
5008 struct elf_i386_link_hash_table
*htab
;
5009 unsigned plt_entry_size
;
5010 const struct elf_i386_backend_data
*abed
;
5011 struct elf_i386_link_hash_entry
*eh
;
5013 htab
= elf_i386_hash_table (info
);
5017 abed
= get_elf_i386_backend_data (output_bfd
);
5018 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5020 eh
= (struct elf_i386_link_hash_entry
*) h
;
5022 if (h
->plt
.offset
!= (bfd_vma
) -1)
5026 Elf_Internal_Rela rel
;
5028 asection
*plt
, *gotplt
, *relplt
;
5030 /* When building a static executable, use .iplt, .igot.plt and
5031 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5032 if (htab
->elf
.splt
!= NULL
)
5034 plt
= htab
->elf
.splt
;
5035 gotplt
= htab
->elf
.sgotplt
;
5036 relplt
= htab
->elf
.srelplt
;
5040 plt
= htab
->elf
.iplt
;
5041 gotplt
= htab
->elf
.igotplt
;
5042 relplt
= htab
->elf
.irelplt
;
5045 /* This symbol has an entry in the procedure linkage table. Set
5048 if ((h
->dynindx
== -1
5049 && !((h
->forced_local
|| bfd_link_executable (info
))
5051 && h
->type
== STT_GNU_IFUNC
))
5057 /* Get the index in the procedure linkage table which
5058 corresponds to this symbol. This is the index of this symbol
5059 in all the symbols for which we are making plt entries. The
5060 first entry in the procedure linkage table is reserved.
5062 Get the offset into the .got table of the entry that
5063 corresponds to this function. Each .got entry is 4 bytes.
5064 The first three are reserved.
5066 For static executables, we don't reserve anything. */
5068 if (plt
== htab
->elf
.splt
)
5070 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5071 got_offset
= (got_offset
+ 3) * 4;
5075 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5076 got_offset
= got_offset
* 4;
5079 /* Fill in the entry in the procedure linkage table. */
5080 if (! bfd_link_pic (info
))
5082 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5083 abed
->plt
->plt_entry_size
);
5084 bfd_put_32 (output_bfd
,
5085 (gotplt
->output_section
->vma
5086 + gotplt
->output_offset
5088 plt
->contents
+ h
->plt
.offset
5089 + abed
->plt
->plt_got_offset
);
5091 if (abed
->is_vxworks
)
5093 int s
, k
, reloc_index
;
5095 /* Create the R_386_32 relocation referencing the GOT
5096 for this PLT entry. */
5098 /* S: Current slot number (zero-based). */
5099 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5100 / abed
->plt
->plt_entry_size
);
5101 /* K: Number of relocations for PLTResolve. */
5102 if (bfd_link_pic (info
))
5103 k
= PLTRESOLVE_RELOCS_SHLIB
;
5105 k
= PLTRESOLVE_RELOCS
;
5106 /* Skip the PLTresolve relocations, and the relocations for
5107 the other PLT slots. */
5108 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5109 loc
= (htab
->srelplt2
->contents
+ reloc_index
5110 * sizeof (Elf32_External_Rel
));
5112 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5113 + htab
->elf
.splt
->output_offset
5114 + h
->plt
.offset
+ 2),
5115 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5116 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5118 /* Create the R_386_32 relocation referencing the beginning of
5119 the PLT for this GOT entry. */
5120 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5121 + htab
->elf
.sgotplt
->output_offset
5123 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5124 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5125 loc
+ sizeof (Elf32_External_Rel
));
5130 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5131 abed
->plt
->plt_entry_size
);
5132 bfd_put_32 (output_bfd
, got_offset
,
5133 plt
->contents
+ h
->plt
.offset
5134 + abed
->plt
->plt_got_offset
);
5137 /* Fill in the entry in the global offset table. */
5138 bfd_put_32 (output_bfd
,
5139 (plt
->output_section
->vma
5140 + plt
->output_offset
5142 + abed
->plt
->plt_lazy_offset
),
5143 gotplt
->contents
+ got_offset
);
5145 /* Fill in the entry in the .rel.plt section. */
5146 rel
.r_offset
= (gotplt
->output_section
->vma
5147 + gotplt
->output_offset
5149 if (h
->dynindx
== -1
5150 || ((bfd_link_executable (info
)
5151 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5153 && h
->type
== STT_GNU_IFUNC
))
5155 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5156 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5157 in the .got.plt section. */
5158 bfd_put_32 (output_bfd
,
5159 (h
->root
.u
.def
.value
5160 + h
->root
.u
.def
.section
->output_section
->vma
5161 + h
->root
.u
.def
.section
->output_offset
),
5162 gotplt
->contents
+ got_offset
);
5163 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5164 /* R_386_IRELATIVE comes last. */
5165 plt_index
= htab
->next_irelative_index
--;
5169 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5170 plt_index
= htab
->next_jump_slot_index
++;
5172 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5173 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5175 /* Don't fill PLT entry for static executables. */
5176 if (plt
== htab
->elf
.splt
)
5178 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
5179 plt
->contents
+ h
->plt
.offset
5180 + abed
->plt
->plt_reloc_offset
);
5181 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5182 + abed
->plt
->plt_plt_offset
+ 4),
5183 plt
->contents
+ h
->plt
.offset
5184 + abed
->plt
->plt_plt_offset
);
5187 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5189 bfd_vma got_offset
, plt_offset
;
5190 asection
*plt
, *got
, *gotplt
;
5191 const bfd_byte
*got_plt_entry
;
5193 /* Offset of displacement of the indirect jump. */
5194 bfd_vma plt_got_offset
= 2;
5196 /* Set the entry in the GOT procedure linkage table. */
5197 plt
= htab
->plt_got
;
5198 got
= htab
->elf
.sgot
;
5199 gotplt
= htab
->elf
.sgotplt
;
5200 got_offset
= h
->got
.offset
;
5202 if (got_offset
== (bfd_vma
) -1
5208 /* Fill in the entry in the GOT procedure linkage table. */
5209 if (! bfd_link_pic (info
))
5211 got_plt_entry
= elf_i386_got_plt_entry
;
5212 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5216 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5217 got_offset
+= (got
->output_section
->vma
5218 + got
->output_offset
5219 - gotplt
->output_section
->vma
5220 - gotplt
->output_offset
);
5223 plt_offset
= eh
->plt_got
.offset
;
5224 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5225 sizeof (elf_i386_got_plt_entry
));
5226 bfd_put_32 (output_bfd
, got_offset
,
5227 plt
->contents
+ plt_offset
+ plt_got_offset
);
5231 && (h
->plt
.offset
!= (bfd_vma
) -1
5232 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5234 /* Mark the symbol as undefined, rather than as defined in
5235 the .plt section. Leave the value if there were any
5236 relocations where pointer equality matters (this is a clue
5237 for the dynamic linker, to make function pointer
5238 comparisons work between an application and shared
5239 library), otherwise set it to zero. If a function is only
5240 called from a binary, there is no need to slow down
5241 shared libraries because of that. */
5242 sym
->st_shndx
= SHN_UNDEF
;
5243 if (!h
->pointer_equality_needed
)
5247 if (h
->got
.offset
!= (bfd_vma
) -1
5248 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5249 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
5251 Elf_Internal_Rela rel
;
5253 /* This symbol has an entry in the global offset table. Set it
5256 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5259 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5260 + htab
->elf
.sgot
->output_offset
5261 + (h
->got
.offset
& ~(bfd_vma
) 1));
5263 /* If this is a static link, or it is a -Bsymbolic link and the
5264 symbol is defined locally or was forced to be local because
5265 of a version file, we just want to emit a RELATIVE reloc.
5266 The entry in the global offset table will already have been
5267 initialized in the relocate_section function. */
5269 && h
->type
== STT_GNU_IFUNC
)
5271 if (bfd_link_pic (info
))
5273 /* Generate R_386_GLOB_DAT. */
5280 if (!h
->pointer_equality_needed
)
5283 /* For non-shared object, we can't use .got.plt, which
5284 contains the real function addres if we need pointer
5285 equality. We load the GOT entry with the PLT entry. */
5286 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5287 bfd_put_32 (output_bfd
,
5288 (plt
->output_section
->vma
5289 + plt
->output_offset
+ h
->plt
.offset
),
5290 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5294 else if (bfd_link_pic (info
)
5295 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5297 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5298 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5302 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5304 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5305 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5306 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5309 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &rel
);
5314 Elf_Internal_Rela rel
;
5316 /* This symbol needs a copy reloc. Set it up. */
5318 if (h
->dynindx
== -1
5319 || (h
->root
.type
!= bfd_link_hash_defined
5320 && h
->root
.type
!= bfd_link_hash_defweak
)
5321 || htab
->srelbss
== NULL
)
5324 rel
.r_offset
= (h
->root
.u
.def
.value
5325 + h
->root
.u
.def
.section
->output_section
->vma
5326 + h
->root
.u
.def
.section
->output_offset
);
5327 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5328 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5334 /* Finish up local dynamic symbol handling. We set the contents of
5335 various dynamic sections here. */
5338 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5340 struct elf_link_hash_entry
*h
5341 = (struct elf_link_hash_entry
*) *slot
;
5342 struct bfd_link_info
*info
5343 = (struct bfd_link_info
*) inf
;
5345 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5349 /* Used to decide how to sort relocs in an optimal manner for the
5350 dynamic linker, before writing them out. */
5352 static enum elf_reloc_type_class
5353 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5354 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5355 const Elf_Internal_Rela
*rela
)
5357 bfd
*abfd
= info
->output_bfd
;
5358 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5359 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5361 if (htab
->dynsym
!= NULL
5362 && htab
->dynsym
->contents
!= NULL
)
5364 /* Check relocation against STT_GNU_IFUNC symbol if there are
5366 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5367 Elf_Internal_Sym sym
;
5368 if (!bed
->s
->swap_symbol_in (abfd
,
5369 (htab
->dynsym
->contents
5370 + r_symndx
* sizeof (Elf32_External_Sym
)),
5374 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5375 return reloc_class_ifunc
;
5378 switch (ELF32_R_TYPE (rela
->r_info
))
5380 case R_386_RELATIVE
:
5381 return reloc_class_relative
;
5382 case R_386_JUMP_SLOT
:
5383 return reloc_class_plt
;
5385 return reloc_class_copy
;
5387 return reloc_class_normal
;
5391 /* Finish up the dynamic sections. */
5394 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5395 struct bfd_link_info
*info
)
5397 struct elf_i386_link_hash_table
*htab
;
5400 const struct elf_i386_backend_data
*abed
;
5402 htab
= elf_i386_hash_table (info
);
5406 dynobj
= htab
->elf
.dynobj
;
5407 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5408 abed
= get_elf_i386_backend_data (output_bfd
);
5410 if (htab
->elf
.dynamic_sections_created
)
5412 Elf32_External_Dyn
*dyncon
, *dynconend
;
5414 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5417 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5418 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5419 for (; dyncon
< dynconend
; dyncon
++)
5421 Elf_Internal_Dyn dyn
;
5424 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5429 if (abed
->is_vxworks
5430 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5435 s
= htab
->elf
.sgotplt
;
5436 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5440 s
= htab
->elf
.srelplt
;
5441 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5445 s
= htab
->elf
.srelplt
;
5446 dyn
.d_un
.d_val
= s
->size
;
5450 /* My reading of the SVR4 ABI indicates that the
5451 procedure linkage table relocs (DT_JMPREL) should be
5452 included in the overall relocs (DT_REL). This is
5453 what Solaris does. However, UnixWare can not handle
5454 that case. Therefore, we override the DT_RELSZ entry
5455 here to make it not include the JMPREL relocs. */
5456 s
= htab
->elf
.srelplt
;
5459 dyn
.d_un
.d_val
-= s
->size
;
5463 /* We may not be using the standard ELF linker script.
5464 If .rel.plt is the first .rel section, we adjust
5465 DT_REL to not include it. */
5466 s
= htab
->elf
.srelplt
;
5469 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5471 dyn
.d_un
.d_ptr
+= s
->size
;
5475 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5478 /* Fill in the first entry in the procedure linkage table. */
5479 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5481 if (bfd_link_pic (info
))
5483 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5484 abed
->plt
->plt0_entry_size
);
5485 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5486 abed
->plt0_pad_byte
,
5487 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5491 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5492 abed
->plt
->plt0_entry_size
);
5493 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5494 abed
->plt0_pad_byte
,
5495 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5496 bfd_put_32 (output_bfd
,
5497 (htab
->elf
.sgotplt
->output_section
->vma
5498 + htab
->elf
.sgotplt
->output_offset
5500 htab
->elf
.splt
->contents
5501 + abed
->plt
->plt0_got1_offset
);
5502 bfd_put_32 (output_bfd
,
5503 (htab
->elf
.sgotplt
->output_section
->vma
5504 + htab
->elf
.sgotplt
->output_offset
5506 htab
->elf
.splt
->contents
5507 + abed
->plt
->plt0_got2_offset
);
5509 if (abed
->is_vxworks
)
5511 Elf_Internal_Rela rel
;
5513 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5514 On IA32 we use REL relocations so the addend goes in
5515 the PLT directly. */
5516 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5517 + htab
->elf
.splt
->output_offset
5518 + abed
->plt
->plt0_got1_offset
);
5519 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5520 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5521 htab
->srelplt2
->contents
);
5522 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5523 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5524 + htab
->elf
.splt
->output_offset
5525 + abed
->plt
->plt0_got2_offset
);
5526 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5527 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5528 htab
->srelplt2
->contents
+
5529 sizeof (Elf32_External_Rel
));
5533 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5534 really seem like the right value. */
5535 elf_section_data (htab
->elf
.splt
->output_section
)
5536 ->this_hdr
.sh_entsize
= 4;
5538 /* Correct the .rel.plt.unloaded relocations. */
5539 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5541 int num_plts
= (htab
->elf
.splt
->size
5542 / abed
->plt
->plt_entry_size
) - 1;
5545 p
= htab
->srelplt2
->contents
;
5546 if (bfd_link_pic (info
))
5547 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5549 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5551 for (; num_plts
; num_plts
--)
5553 Elf_Internal_Rela rel
;
5554 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5555 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5556 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5557 p
+= sizeof (Elf32_External_Rel
);
5559 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5560 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5561 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5562 p
+= sizeof (Elf32_External_Rel
);
5568 if (htab
->elf
.sgotplt
)
5570 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5572 (*_bfd_error_handler
)
5573 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5577 /* Fill in the first three entries in the global offset table. */
5578 if (htab
->elf
.sgotplt
->size
> 0)
5580 bfd_put_32 (output_bfd
,
5582 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5583 htab
->elf
.sgotplt
->contents
);
5584 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5585 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5588 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5591 /* Adjust .eh_frame for .plt section. */
5592 if (htab
->plt_eh_frame
!= NULL
5593 && htab
->plt_eh_frame
->contents
!= NULL
)
5595 if (htab
->elf
.splt
!= NULL
5596 && htab
->elf
.splt
->size
!= 0
5597 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5598 && htab
->elf
.splt
->output_section
!= NULL
5599 && htab
->plt_eh_frame
->output_section
!= NULL
)
5601 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5602 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5603 + htab
->plt_eh_frame
->output_offset
5604 + PLT_FDE_START_OFFSET
;
5605 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5606 htab
->plt_eh_frame
->contents
5607 + PLT_FDE_START_OFFSET
);
5609 if (htab
->plt_eh_frame
->sec_info_type
5610 == SEC_INFO_TYPE_EH_FRAME
)
5612 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5614 htab
->plt_eh_frame
->contents
))
5619 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5620 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5622 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5623 htab_traverse (htab
->loc_hash_table
,
5624 elf_i386_finish_local_dynamic_symbol
,
5630 /* Return an array of PLT entry symbol values. */
5633 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5636 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5639 bfd_vma
*plt_sym_val
;
5641 bfd_byte
*plt_contents
;
5642 const struct elf_i386_backend_data
*bed
5643 = get_elf_i386_backend_data (abfd
);
5644 Elf_Internal_Shdr
*hdr
;
5646 /* Get the .plt section contents. */
5647 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5648 if (plt_contents
== NULL
)
5650 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5651 plt_contents
, 0, plt
->size
))
5654 free (plt_contents
);
5658 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5659 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5662 hdr
= &elf_section_data (relplt
)->this_hdr
;
5663 count
= relplt
->size
/ hdr
->sh_entsize
;
5665 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5666 if (plt_sym_val
== NULL
)
5669 for (i
= 0; i
< count
; i
++)
5670 plt_sym_val
[i
] = -1;
5672 plt_offset
= bed
->plt
->plt_entry_size
;
5673 p
= relplt
->relocation
;
5674 for (i
= 0; i
< count
; i
++, p
++)
5678 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5679 if (p
->howto
== NULL
)
5682 if (p
->howto
->type
!= R_386_JUMP_SLOT
5683 && p
->howto
->type
!= R_386_IRELATIVE
)
5686 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5687 + bed
->plt
->plt_reloc_offset
));
5688 reloc_index
/= sizeof (Elf32_External_Rel
);
5689 if (reloc_index
< count
)
5690 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5692 plt_offset
+= bed
->plt
->plt_entry_size
;
5694 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5696 if (plt_offset
>= plt
->size
)
5700 free (plt_contents
);
5705 /* Similar to _bfd_elf_get_synthetic_symtab. */
5708 elf_i386_get_synthetic_symtab (bfd
*abfd
,
5715 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
5716 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5717 dynsymcount
, dynsyms
, ret
,
5719 elf_i386_get_plt_sym_val
);
5722 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5725 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
5727 if (h
->plt
.offset
!= (bfd_vma
) -1
5729 && !h
->pointer_equality_needed
)
5732 return _bfd_elf_hash_symbol (h
);
5735 /* Hook called by the linker routine which adds symbols from an object
5739 elf_i386_add_symbol_hook (bfd
* abfd
,
5740 struct bfd_link_info
* info
,
5741 Elf_Internal_Sym
* sym
,
5742 const char ** namep ATTRIBUTE_UNUSED
,
5743 flagword
* flagsp ATTRIBUTE_UNUSED
,
5744 asection
** secp ATTRIBUTE_UNUSED
,
5745 bfd_vma
* valp ATTRIBUTE_UNUSED
)
5747 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
5748 && (abfd
->flags
& DYNAMIC
) == 0
5749 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5750 elf_tdata (info
->output_bfd
)->has_gnu_symbols
5751 |= elf_gnu_symbol_unique
;
5756 #define TARGET_LITTLE_SYM i386_elf32_vec
5757 #define TARGET_LITTLE_NAME "elf32-i386"
5758 #define ELF_ARCH bfd_arch_i386
5759 #define ELF_TARGET_ID I386_ELF_DATA
5760 #define ELF_MACHINE_CODE EM_386
5761 #define ELF_MAXPAGESIZE 0x1000
5763 #define elf_backend_can_gc_sections 1
5764 #define elf_backend_can_refcount 1
5765 #define elf_backend_want_got_plt 1
5766 #define elf_backend_plt_readonly 1
5767 #define elf_backend_want_plt_sym 0
5768 #define elf_backend_got_header_size 12
5769 #define elf_backend_plt_alignment 4
5770 #define elf_backend_extern_protected_data 1
5772 /* Support RELA for objdump of prelink objects. */
5773 #define elf_info_to_howto elf_i386_info_to_howto_rel
5774 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5776 #define bfd_elf32_mkobject elf_i386_mkobject
5778 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5779 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5780 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5781 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5782 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5784 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5785 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5786 #define elf_backend_check_relocs elf_i386_check_relocs
5787 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5788 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5789 #define elf_backend_fake_sections elf_i386_fake_sections
5790 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5791 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5792 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5793 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
5794 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5795 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5796 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5797 #define elf_backend_relocate_section elf_i386_relocate_section
5798 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5799 #define elf_backend_always_size_sections elf_i386_always_size_sections
5800 #define elf_backend_omit_section_dynsym \
5801 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5802 #define elf_backend_hash_symbol elf_i386_hash_symbol
5803 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5805 #include "elf32-target.h"
5807 /* FreeBSD support. */
5809 #undef TARGET_LITTLE_SYM
5810 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5811 #undef TARGET_LITTLE_NAME
5812 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5814 #define ELF_OSABI ELFOSABI_FREEBSD
5816 /* The kernel recognizes executables as valid only if they carry a
5817 "FreeBSD" label in the ELF header. So we put this label on all
5818 executables and (for simplicity) also all other object files. */
5821 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
5823 _bfd_elf_post_process_headers (abfd
, info
);
5825 #ifdef OLD_FREEBSD_ABI_LABEL
5827 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5828 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5829 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5834 #undef elf_backend_post_process_headers
5835 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5837 #define elf32_bed elf32_i386_fbsd_bed
5839 #undef elf_backend_add_symbol_hook
5841 #include "elf32-target.h"
5845 #undef TARGET_LITTLE_SYM
5846 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5847 #undef TARGET_LITTLE_NAME
5848 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5850 #undef elf_backend_post_process_headers
5852 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5853 objects won't be recognized. */
5857 #define elf32_bed elf32_i386_sol2_bed
5859 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5861 #undef elf_backend_static_tls_alignment
5862 #define elf_backend_static_tls_alignment 8
5864 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5866 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5868 #undef elf_backend_want_plt_sym
5869 #define elf_backend_want_plt_sym 1
5871 #include "elf32-target.h"
5873 /* Intel MCU support. */
5876 elf32_iamcu_elf_object_p (bfd
*abfd
)
5878 /* Set the right machine number for an IAMCU elf32 file. */
5879 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
5883 #undef TARGET_LITTLE_SYM
5884 #define TARGET_LITTLE_SYM iamcu_elf32_vec
5885 #undef TARGET_LITTLE_NAME
5886 #define TARGET_LITTLE_NAME "elf32-iamcu"
5888 #define ELF_ARCH bfd_arch_iamcu
5890 #undef ELF_MACHINE_CODE
5891 #define ELF_MACHINE_CODE EM_IAMCU
5896 #define elf32_bed elf32_iamcu_bed
5898 #undef elf_backend_object_p
5899 #define elf_backend_object_p elf32_iamcu_elf_object_p
5901 #undef elf_backend_static_tls_alignment
5903 #undef elf_backend_want_plt_sym
5904 #define elf_backend_want_plt_sym 0
5906 #include "elf32-target.h"
5908 /* Restore defaults. */
5910 #define ELF_ARCH bfd_arch_i386
5911 #undef ELF_MACHINE_CODE
5912 #define ELF_MACHINE_CODE EM_386
5914 /* Native Client support. */
5916 #undef TARGET_LITTLE_SYM
5917 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
5918 #undef TARGET_LITTLE_NAME
5919 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
5921 #define elf32_bed elf32_i386_nacl_bed
5923 #undef ELF_MAXPAGESIZE
5924 #define ELF_MAXPAGESIZE 0x10000
5926 /* Restore defaults. */
5928 #undef elf_backend_want_plt_sym
5929 #define elf_backend_want_plt_sym 0
5930 #undef elf_backend_post_process_headers
5931 #undef elf_backend_static_tls_alignment
5933 /* NaCl uses substantially different PLT entries for the same effects. */
5935 #undef elf_backend_plt_alignment
5936 #define elf_backend_plt_alignment 5
5937 #define NACL_PLT_ENTRY_SIZE 64
5938 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5940 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
5942 0xff, 0x35, /* pushl contents of address */
5943 0, 0, 0, 0, /* replaced with address of .got + 4. */
5944 0x8b, 0x0d, /* movl contents of address, %ecx */
5945 0, 0, 0, 0, /* replaced with address of .got + 8. */
5946 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
5947 0xff, 0xe1 /* jmp *%ecx */
5950 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5952 0x8b, 0x0d, /* movl contents of address, %ecx */
5953 0, 0, 0, 0, /* replaced with GOT slot address. */
5954 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
5955 0xff, 0xe1, /* jmp *%ecx */
5957 /* Pad to the next 32-byte boundary with nop instructions. */
5959 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5960 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5962 /* Lazy GOT entries point here (32-byte aligned). */
5963 0x68, /* pushl immediate */
5964 0, 0, 0, 0, /* replaced with reloc offset. */
5965 0xe9, /* jmp relative */
5966 0, 0, 0, 0, /* replaced with offset to .plt. */
5968 /* Pad to the next 32-byte boundary with nop instructions. */
5969 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5970 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5974 static const bfd_byte
5975 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
5977 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
5978 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
5979 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
5980 0xff, 0xe1, /* jmp *%ecx */
5982 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5983 so pad to that size with nop instructions. */
5984 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5987 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5989 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
5990 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
5991 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
5992 0xff, 0xe1, /* jmp *%ecx */
5994 /* Pad to the next 32-byte boundary with nop instructions. */
5996 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5997 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5999 /* Lazy GOT entries point here (32-byte aligned). */
6000 0x68, /* pushl immediate */
6001 0, 0, 0, 0, /* replaced with offset into relocation table. */
6002 0xe9, /* jmp relative */
6003 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6005 /* Pad to the next 32-byte boundary with nop instructions. */
6006 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6007 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6011 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6013 #if (PLT_CIE_LENGTH != 20 \
6014 || PLT_FDE_LENGTH != 36 \
6015 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6016 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6017 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6019 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6020 0, 0, 0, 0, /* CIE ID */
6021 1, /* CIE version */
6022 'z', 'R', 0, /* Augmentation string */
6023 1, /* Code alignment factor */
6024 0x7c, /* Data alignment factor: -4 */
6025 8, /* Return address column */
6026 1, /* Augmentation size */
6027 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6028 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6029 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6030 DW_CFA_nop
, DW_CFA_nop
,
6032 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6033 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6034 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6035 0, 0, 0, 0, /* .plt size goes here */
6036 0, /* Augmentation size */
6037 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6038 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6039 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6040 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6041 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6042 13, /* Block length */
6043 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6044 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6045 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6046 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6047 DW_CFA_nop
, DW_CFA_nop
6050 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6052 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6053 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6054 2, /* plt0_got1_offset */
6055 8, /* plt0_got2_offset */
6056 elf_i386_nacl_plt_entry
, /* plt_entry */
6057 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6058 2, /* plt_got_offset */
6059 33, /* plt_reloc_offset */
6060 38, /* plt_plt_offset */
6061 32, /* plt_lazy_offset */
6062 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6063 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6064 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6065 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6068 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6070 &elf_i386_nacl_plt
, /* plt */
6071 0x90, /* plt0_pad_byte: nop insn */
6076 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6078 /* Set the right machine number for a NaCl i386 ELF32 file. */
6079 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6083 #undef elf_backend_arch_data
6084 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6086 #undef elf_backend_object_p
6087 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6088 #undef elf_backend_modify_segment_map
6089 #define elf_backend_modify_segment_map nacl_modify_segment_map
6090 #undef elf_backend_modify_program_headers
6091 #define elf_backend_modify_program_headers nacl_modify_program_headers
6092 #undef elf_backend_final_write_processing
6093 #define elf_backend_final_write_processing nacl_final_write_processing
6095 #include "elf32-target.h"
6097 /* Restore defaults. */
6098 #undef elf_backend_object_p
6099 #undef elf_backend_modify_segment_map
6100 #undef elf_backend_modify_program_headers
6101 #undef elf_backend_final_write_processing
6103 /* VxWorks support. */
6105 #undef TARGET_LITTLE_SYM
6106 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6107 #undef TARGET_LITTLE_NAME
6108 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6110 #undef elf_backend_plt_alignment
6111 #define elf_backend_plt_alignment 4
6113 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6115 &elf_i386_plt
, /* plt */
6116 0x90, /* plt0_pad_byte */
6120 #undef elf_backend_arch_data
6121 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6123 #undef elf_backend_relocs_compatible
6124 #undef elf_backend_add_symbol_hook
6125 #define elf_backend_add_symbol_hook \
6126 elf_vxworks_add_symbol_hook
6127 #undef elf_backend_link_output_symbol_hook
6128 #define elf_backend_link_output_symbol_hook \
6129 elf_vxworks_link_output_symbol_hook
6130 #undef elf_backend_emit_relocs
6131 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6132 #undef elf_backend_final_write_processing
6133 #define elf_backend_final_write_processing \
6134 elf_vxworks_final_write_processing
6135 #undef elf_backend_static_tls_alignment
6137 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6139 #undef elf_backend_want_plt_sym
6140 #define elf_backend_want_plt_sym 1
6143 #define elf32_bed elf32_i386_vxworks_bed
6145 #include "elf32-target.h"