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 /* Is a undefined weak symbol which is resolved to 0. Reference to an
741 undefined weak symbol is resolved to 0 when building executable if
743 1. Has non-GOT/non-PLT relocations in text section. Or
744 2. Has no GOT/PLT relocation.
746 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
751 || (EH)->has_non_got_reloc \
752 || !(INFO)->dynamic_undefined_weak))
754 /* i386 ELF linker hash entry. */
756 struct elf_i386_link_hash_entry
758 struct elf_link_hash_entry elf
;
760 /* Track dynamic relocs copied for this symbol. */
761 struct elf_dyn_relocs
*dyn_relocs
;
763 #define GOT_UNKNOWN 0
767 #define GOT_TLS_IE_POS 5
768 #define GOT_TLS_IE_NEG 6
769 #define GOT_TLS_IE_BOTH 7
770 #define GOT_TLS_GDESC 8
771 #define GOT_TLS_GD_BOTH_P(type) \
772 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
773 #define GOT_TLS_GD_P(type) \
774 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
775 #define GOT_TLS_GDESC_P(type) \
776 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GD_ANY_P(type) \
778 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
779 unsigned char tls_type
;
781 /* Symbol is referenced by R_386_GOTOFF relocation. */
782 unsigned int gotoff_ref
: 1;
784 /* Symbol has GOT or PLT relocations. */
785 unsigned int has_got_reloc
: 1;
787 /* Symbol has non-GOT/non-PLT relocations in text sections. */
788 unsigned int has_non_got_reloc
: 1;
790 /* Reference count of C/C++ function pointer relocations in read-write
791 section which can be resolved at run-time. */
792 bfd_signed_vma func_pointer_refcount
;
794 /* Information about the GOT PLT entry. Filled when there are both
795 GOT and PLT relocations against the same function. */
796 union gotplt_union plt_got
;
798 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
799 starting at the end of the jump table. */
803 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
805 struct elf_i386_obj_tdata
807 struct elf_obj_tdata root
;
809 /* tls_type for each local got entry. */
810 char *local_got_tls_type
;
812 /* GOTPLT entries for TLS descriptors. */
813 bfd_vma
*local_tlsdesc_gotent
;
816 #define elf_i386_tdata(abfd) \
817 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
819 #define elf_i386_local_got_tls_type(abfd) \
820 (elf_i386_tdata (abfd)->local_got_tls_type)
822 #define elf_i386_local_tlsdesc_gotent(abfd) \
823 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
825 #define is_i386_elf(bfd) \
826 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
827 && elf_tdata (bfd) != NULL \
828 && elf_object_id (bfd) == I386_ELF_DATA)
831 elf_i386_mkobject (bfd
*abfd
)
833 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
837 /* i386 ELF linker hash table. */
839 struct elf_i386_link_hash_table
841 struct elf_link_hash_table elf
;
843 /* Short-cuts to get to dynamic linker sections. */
847 asection
*plt_eh_frame
;
852 bfd_signed_vma refcount
;
856 /* The amount of space used by the reserved portion of the sgotplt
857 section, plus whatever space is used by the jump slots. */
858 bfd_vma sgotplt_jump_table_size
;
860 /* Small local sym cache. */
861 struct sym_cache sym_cache
;
863 /* _TLS_MODULE_BASE_ symbol. */
864 struct bfd_link_hash_entry
*tls_module_base
;
866 /* Used by local STT_GNU_IFUNC symbols. */
867 htab_t loc_hash_table
;
868 void * loc_hash_memory
;
870 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
873 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
874 bfd_vma next_tls_desc_index
;
876 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
877 bfd_vma next_jump_slot_index
;
879 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
880 bfd_vma next_irelative_index
;
882 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
883 to read-only sections. */
884 bfd_boolean readonly_dynrelocs_against_ifunc
;
887 /* Get the i386 ELF linker hash table from a link_info structure. */
889 #define elf_i386_hash_table(p) \
890 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
891 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
893 #define elf_i386_compute_jump_table_size(htab) \
894 ((htab)->elf.srelplt->reloc_count * 4)
896 /* Create an entry in an i386 ELF linker hash table. */
898 static struct bfd_hash_entry
*
899 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
900 struct bfd_hash_table
*table
,
903 /* Allocate the structure if it has not already been allocated by a
907 entry
= (struct bfd_hash_entry
*)
908 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
913 /* Call the allocation method of the superclass. */
914 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
917 struct elf_i386_link_hash_entry
*eh
;
919 eh
= (struct elf_i386_link_hash_entry
*) entry
;
920 eh
->dyn_relocs
= NULL
;
921 eh
->tls_type
= GOT_UNKNOWN
;
923 eh
->has_got_reloc
= 0;
924 eh
->has_non_got_reloc
= 0;
925 eh
->func_pointer_refcount
= 0;
926 eh
->plt_got
.offset
= (bfd_vma
) -1;
927 eh
->tlsdesc_got
= (bfd_vma
) -1;
933 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
934 for local symbol so that we can handle local STT_GNU_IFUNC symbols
935 as global symbol. We reuse indx and dynstr_index for local symbol
936 hash since they aren't used by global symbols in this backend. */
939 elf_i386_local_htab_hash (const void *ptr
)
941 struct elf_link_hash_entry
*h
942 = (struct elf_link_hash_entry
*) ptr
;
943 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
946 /* Compare local hash entries. */
949 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
951 struct elf_link_hash_entry
*h1
952 = (struct elf_link_hash_entry
*) ptr1
;
953 struct elf_link_hash_entry
*h2
954 = (struct elf_link_hash_entry
*) ptr2
;
956 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
959 /* Find and/or create a hash entry for local symbol. */
961 static struct elf_link_hash_entry
*
962 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
963 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
966 struct elf_i386_link_hash_entry e
, *ret
;
967 asection
*sec
= abfd
->sections
;
968 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
969 ELF32_R_SYM (rel
->r_info
));
972 e
.elf
.indx
= sec
->id
;
973 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
974 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
975 create
? INSERT
: NO_INSERT
);
982 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
986 ret
= (struct elf_i386_link_hash_entry
*)
987 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
988 sizeof (struct elf_i386_link_hash_entry
));
991 memset (ret
, 0, sizeof (*ret
));
992 ret
->elf
.indx
= sec
->id
;
993 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
994 ret
->elf
.dynindx
= -1;
995 ret
->func_pointer_refcount
= 0;
996 ret
->plt_got
.offset
= (bfd_vma
) -1;
1002 /* Destroy an i386 ELF linker hash table. */
1005 elf_i386_link_hash_table_free (bfd
*obfd
)
1007 struct elf_i386_link_hash_table
*htab
1008 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1010 if (htab
->loc_hash_table
)
1011 htab_delete (htab
->loc_hash_table
);
1012 if (htab
->loc_hash_memory
)
1013 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1014 _bfd_elf_link_hash_table_free (obfd
);
1017 /* Create an i386 ELF linker hash table. */
1019 static struct bfd_link_hash_table
*
1020 elf_i386_link_hash_table_create (bfd
*abfd
)
1022 struct elf_i386_link_hash_table
*ret
;
1023 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1025 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1029 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1030 elf_i386_link_hash_newfunc
,
1031 sizeof (struct elf_i386_link_hash_entry
),
1038 ret
->loc_hash_table
= htab_try_create (1024,
1039 elf_i386_local_htab_hash
,
1040 elf_i386_local_htab_eq
,
1042 ret
->loc_hash_memory
= objalloc_create ();
1043 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1045 elf_i386_link_hash_table_free (abfd
);
1048 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1050 return &ret
->elf
.root
;
1053 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1054 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1060 struct elf_i386_link_hash_table
*htab
;
1062 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1065 htab
= elf_i386_hash_table (info
);
1069 /* Set the contents of the .interp section to the interpreter. */
1070 if (bfd_link_executable (info
) && !info
->nointerp
)
1072 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1075 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1076 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1080 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1084 if (bfd_link_executable (info
))
1086 /* Always allow copy relocs for building executables. */
1087 asection
*s
= bfd_get_linker_section (dynobj
, ".rel.bss");
1090 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1091 s
= bfd_make_section_anyway_with_flags (dynobj
,
1093 (bed
->dynamic_sec_flags
1096 || ! bfd_set_section_alignment (dynobj
, s
,
1097 bed
->s
->log_file_align
))
1103 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1104 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1108 if (!info
->no_ld_generated_unwind_info
1109 && htab
->plt_eh_frame
== NULL
1110 && htab
->elf
.splt
!= NULL
)
1112 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1113 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1114 | SEC_LINKER_CREATED
);
1116 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1117 if (htab
->plt_eh_frame
== NULL
1118 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1125 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1128 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1129 struct elf_link_hash_entry
*dir
,
1130 struct elf_link_hash_entry
*ind
)
1132 struct elf_i386_link_hash_entry
*edir
, *eind
;
1134 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1135 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1137 if (eind
->dyn_relocs
!= NULL
)
1139 if (edir
->dyn_relocs
!= NULL
)
1141 struct elf_dyn_relocs
**pp
;
1142 struct elf_dyn_relocs
*p
;
1144 /* Add reloc counts against the indirect sym to the direct sym
1145 list. Merge any entries against the same section. */
1146 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1148 struct elf_dyn_relocs
*q
;
1150 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1151 if (q
->sec
== p
->sec
)
1153 q
->pc_count
+= p
->pc_count
;
1154 q
->count
+= p
->count
;
1161 *pp
= edir
->dyn_relocs
;
1164 edir
->dyn_relocs
= eind
->dyn_relocs
;
1165 eind
->dyn_relocs
= NULL
;
1168 if (ind
->root
.type
== bfd_link_hash_indirect
1169 && dir
->got
.refcount
<= 0)
1171 edir
->tls_type
= eind
->tls_type
;
1172 eind
->tls_type
= GOT_UNKNOWN
;
1175 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1176 generate a R_386_COPY reloc. */
1177 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1179 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1180 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1182 if (ELIMINATE_COPY_RELOCS
1183 && ind
->root
.type
!= bfd_link_hash_indirect
1184 && dir
->dynamic_adjusted
)
1186 /* If called to transfer flags for a weakdef during processing
1187 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1188 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1189 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1190 dir
->ref_regular
|= ind
->ref_regular
;
1191 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1192 dir
->needs_plt
|= ind
->needs_plt
;
1193 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1197 if (eind
->func_pointer_refcount
> 0)
1199 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1200 eind
->func_pointer_refcount
= 0;
1203 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1207 /* Return TRUE if the TLS access code sequence support transition
1211 elf_i386_check_tls_transition (asection
*sec
,
1213 Elf_Internal_Shdr
*symtab_hdr
,
1214 struct elf_link_hash_entry
**sym_hashes
,
1215 unsigned int r_type
,
1216 const Elf_Internal_Rela
*rel
,
1217 const Elf_Internal_Rela
*relend
)
1219 unsigned int val
, type
;
1220 unsigned long r_symndx
;
1221 struct elf_link_hash_entry
*h
;
1224 offset
= rel
->r_offset
;
1229 if (offset
< 2 || (rel
+ 1) >= relend
)
1232 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1233 if (r_type
== R_386_TLS_GD
)
1235 /* Check transition from GD access model. Only
1236 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1237 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1238 can transit to different access model. */
1239 if ((offset
+ 10) > sec
->size
||
1240 (type
!= 0x8d && type
!= 0x04))
1243 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1246 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1250 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
1253 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
1258 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1259 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1262 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1268 /* Check transition from LD access model. Only
1269 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1270 can transit to different access model. */
1271 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1274 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1275 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1279 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1282 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1283 if (r_symndx
< symtab_hdr
->sh_info
)
1286 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1287 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1288 may be versioned. */
1290 && h
->root
.root
.string
!= NULL
1291 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1292 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1293 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1297 /* Check transition from IE access model:
1298 movl foo@indntpoff(%rip), %eax
1299 movl foo@indntpoff(%rip), %reg
1300 addl foo@indntpoff(%rip), %reg
1303 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1306 /* Check "movl foo@tpoff(%rip), %eax" first. */
1307 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1314 /* Check movl|addl foo@tpoff(%rip), %reg. */
1315 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1316 return ((type
== 0x8b || type
== 0x03)
1317 && (val
& 0xc7) == 0x05);
1319 case R_386_TLS_GOTIE
:
1320 case R_386_TLS_IE_32
:
1321 /* Check transition from {IE_32,GOTIE} access model:
1322 subl foo@{tpoff,gontoff}(%reg1), %reg2
1323 movl foo@{tpoff,gontoff}(%reg1), %reg2
1324 addl foo@{tpoff,gontoff}(%reg1), %reg2
1327 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1330 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1331 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1334 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1335 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1337 case R_386_TLS_GOTDESC
:
1338 /* Check transition from GDesc access model:
1339 leal x@tlsdesc(%ebx), %eax
1341 Make sure it's a leal adding ebx to a 32-bit offset
1342 into any register, although it's probably almost always
1345 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1348 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1351 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1352 return (val
& 0xc7) == 0x83;
1354 case R_386_TLS_DESC_CALL
:
1355 /* Check transition from GDesc access model:
1356 call *x@tlsdesc(%rax)
1358 if (offset
+ 2 <= sec
->size
)
1360 /* Make sure that it's a call *x@tlsdesc(%rax). */
1361 static const unsigned char call
[] = { 0xff, 0x10 };
1362 return memcmp (contents
+ offset
, call
, 2) == 0;
1372 /* Return TRUE if the TLS access transition is OK or no transition
1373 will be performed. Update R_TYPE if there is a transition. */
1376 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1377 asection
*sec
, bfd_byte
*contents
,
1378 Elf_Internal_Shdr
*symtab_hdr
,
1379 struct elf_link_hash_entry
**sym_hashes
,
1380 unsigned int *r_type
, int tls_type
,
1381 const Elf_Internal_Rela
*rel
,
1382 const Elf_Internal_Rela
*relend
,
1383 struct elf_link_hash_entry
*h
,
1384 unsigned long r_symndx
,
1385 bfd_boolean from_relocate_section
)
1387 unsigned int from_type
= *r_type
;
1388 unsigned int to_type
= from_type
;
1389 bfd_boolean check
= TRUE
;
1391 /* Skip TLS transition for functions. */
1393 && (h
->type
== STT_FUNC
1394 || h
->type
== STT_GNU_IFUNC
))
1400 case R_386_TLS_GOTDESC
:
1401 case R_386_TLS_DESC_CALL
:
1402 case R_386_TLS_IE_32
:
1404 case R_386_TLS_GOTIE
:
1405 if (bfd_link_executable (info
))
1408 to_type
= R_386_TLS_LE_32
;
1409 else if (from_type
!= R_386_TLS_IE
1410 && from_type
!= R_386_TLS_GOTIE
)
1411 to_type
= R_386_TLS_IE_32
;
1414 /* When we are called from elf_i386_relocate_section, there may
1415 be additional transitions based on TLS_TYPE. */
1416 if (from_relocate_section
)
1418 unsigned int new_to_type
= to_type
;
1420 if (bfd_link_executable (info
)
1423 && (tls_type
& GOT_TLS_IE
))
1424 new_to_type
= R_386_TLS_LE_32
;
1426 if (to_type
== R_386_TLS_GD
1427 || to_type
== R_386_TLS_GOTDESC
1428 || to_type
== R_386_TLS_DESC_CALL
)
1430 if (tls_type
== GOT_TLS_IE_POS
)
1431 new_to_type
= R_386_TLS_GOTIE
;
1432 else if (tls_type
& GOT_TLS_IE
)
1433 new_to_type
= R_386_TLS_IE_32
;
1436 /* We checked the transition before when we were called from
1437 elf_i386_check_relocs. We only want to check the new
1438 transition which hasn't been checked before. */
1439 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1440 to_type
= new_to_type
;
1446 if (bfd_link_executable (info
))
1447 to_type
= R_386_TLS_LE_32
;
1454 /* Return TRUE if there is no transition. */
1455 if (from_type
== to_type
)
1458 /* Check if the transition can be performed. */
1460 && ! elf_i386_check_tls_transition (sec
, contents
,
1461 symtab_hdr
, sym_hashes
,
1462 from_type
, rel
, relend
))
1464 reloc_howto_type
*from
, *to
;
1467 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1468 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1471 name
= h
->root
.root
.string
;
1474 struct elf_i386_link_hash_table
*htab
;
1476 htab
= elf_i386_hash_table (info
);
1481 Elf_Internal_Sym
*isym
;
1483 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1485 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1489 (*_bfd_error_handler
)
1490 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1491 "in section `%A' failed"),
1492 abfd
, sec
, from
->name
, to
->name
, name
,
1493 (unsigned long) rel
->r_offset
);
1494 bfd_set_error (bfd_error_bad_value
);
1502 /* With the local symbol, foo, we convert
1503 mov foo@GOT[(%reg1)], %reg2
1505 lea foo[@GOTOFF(%reg1)], %reg2
1507 call/jmp *foo@GOT[(%reg)]
1509 nop call foo/jmp foo nop
1510 When PIC is false, convert
1511 test %reg1, foo@GOT[(%reg2)]
1515 binop foo@GOT[(%reg1)], %reg2
1518 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1523 elf_i386_convert_load_reloc (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
1525 Elf_Internal_Rela
*irel
,
1526 struct elf_link_hash_entry
*h
,
1527 bfd_boolean
*converted
,
1528 struct bfd_link_info
*link_info
)
1530 struct elf_i386_link_hash_table
*htab
;
1531 unsigned int opcode
;
1533 bfd_boolean baseless
;
1534 Elf_Internal_Sym
*isym
;
1535 unsigned int addend
;
1539 bfd_boolean to_reloc_32
;
1540 unsigned int r_type
;
1541 unsigned int r_symndx
;
1542 bfd_vma roff
= irel
->r_offset
;
1547 /* Addend for R_386_GOT32X relocations must be 0. */
1548 addend
= bfd_get_32 (abfd
, contents
+ roff
);
1552 htab
= elf_i386_hash_table (link_info
);
1553 is_pic
= bfd_link_pic (link_info
);
1555 r_type
= ELF32_R_TYPE (irel
->r_info
);
1556 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1558 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1559 baseless
= (modrm
& 0xc7) == 0x5;
1561 if (baseless
&& is_pic
)
1563 /* For PIC, disallow R_386_GOT32X without a base register
1564 since we don't know what the GOT base is. */
1569 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
1571 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1574 name
= h
->root
.root
.string
;
1576 (*_bfd_error_handler
)
1577 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1582 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1584 /* Convert to R_386_32 if PIC is false or there is no base
1586 to_reloc_32
= !is_pic
|| baseless
;
1588 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1592 if (opcode
== 0x0ff)
1593 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1594 goto convert_branch
;
1596 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1597 "test %reg1, foo@GOT(%reg2)" and
1598 "binop foo@GOT[(%reg1)], %reg2". */
1602 /* Undefined weak symbol is only bound locally in executable
1603 and its reference is resolved as 0. */
1604 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
1605 elf_i386_hash_entry (h
)))
1609 /* No direct branch to 0 for PIC. */
1613 goto convert_branch
;
1617 /* We can convert load of address 0 to R_386_32. */
1625 /* We have "call/jmp *foo@GOT[(%reg)]". */
1626 if ((h
->root
.type
== bfd_link_hash_defined
1627 || h
->root
.type
== bfd_link_hash_defweak
)
1628 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1630 /* The function is locally defined. */
1632 /* Convert R_386_GOT32X to R_386_PC32. */
1633 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
1635 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1638 nop
= link_info
->call_nop_byte
;
1639 if (link_info
->call_nop_as_suffix
)
1641 nop_offset
= roff
+ 3;
1642 irel
->r_offset
-= 1;
1645 nop_offset
= roff
- 2;
1649 /* Convert to "jmp foo nop". */
1652 nop_offset
= roff
+ 3;
1653 irel
->r_offset
-= 1;
1656 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1657 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1658 /* When converting to PC-relative relocation, we
1659 need to adjust addend by -4. */
1660 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
1661 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
1668 /* We have "mov foo@GOT[(%re1g)], %reg2",
1669 "test %reg1, foo@GOT(%reg2)" and
1670 "binop foo@GOT[(%reg1)], %reg2".
1672 Avoid optimizing _DYNAMIC since ld.so may use its
1673 link-time address. */
1674 if (h
== htab
->elf
.hdynamic
)
1677 /* def_regular is set by an assignment in a linker script in
1678 bfd_elf_record_link_assignment. */
1680 || h
->root
.type
== bfd_link_hash_defined
1681 || h
->root
.type
== bfd_link_hash_defweak
)
1682 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1689 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1690 "mov $foo, %reg2" with R_386_32. */
1692 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1693 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1698 /* Convert "mov foo@GOT(%reg1), %reg2" to
1699 "lea foo@GOTOFF(%reg1), %reg2". */
1700 r_type
= R_386_GOTOFF
;
1706 /* Only R_386_32 is supported. */
1712 /* Convert "test %reg1, foo@GOT(%reg2)" to
1713 "test $foo, %reg1". */
1714 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1719 /* Convert "binop foo@GOT(%reg1), %reg2" to
1720 "binop $foo, %reg2". */
1722 | (modrm
& 0x38) >> 3
1726 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1730 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1731 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1740 /* Rename some of the generic section flags to better document how they
1742 #define need_convert_load sec_flg0
1743 #define check_relocs_failed sec_flg1
1745 /* Look through the relocs for a section during the first phase, and
1746 calculate needed space in the global offset table, procedure linkage
1747 table, and dynamic reloc sections. */
1750 elf_i386_check_relocs (bfd
*abfd
,
1751 struct bfd_link_info
*info
,
1753 const Elf_Internal_Rela
*relocs
)
1755 struct elf_i386_link_hash_table
*htab
;
1756 Elf_Internal_Shdr
*symtab_hdr
;
1757 struct elf_link_hash_entry
**sym_hashes
;
1758 const Elf_Internal_Rela
*rel
;
1759 const Elf_Internal_Rela
*rel_end
;
1762 bfd_boolean use_plt_got
;
1764 if (bfd_link_relocatable (info
))
1767 BFD_ASSERT (is_i386_elf (abfd
));
1769 htab
= elf_i386_hash_table (info
);
1772 sec
->check_relocs_failed
= 1;
1776 /* Get the section contents. */
1777 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1778 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1779 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1781 sec
->check_relocs_failed
= 1;
1785 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1786 && (get_elf_i386_backend_data (abfd
)
1787 == &elf_i386_arch_bed
));
1789 symtab_hdr
= &elf_symtab_hdr (abfd
);
1790 sym_hashes
= elf_sym_hashes (abfd
);
1794 rel_end
= relocs
+ sec
->reloc_count
;
1795 for (rel
= relocs
; rel
< rel_end
; rel
++)
1797 unsigned int r_type
;
1798 unsigned long r_symndx
;
1799 struct elf_link_hash_entry
*h
;
1800 struct elf_i386_link_hash_entry
*eh
;
1801 Elf_Internal_Sym
*isym
;
1803 bfd_boolean size_reloc
;
1805 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1806 r_type
= ELF32_R_TYPE (rel
->r_info
);
1808 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1810 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1816 if (r_symndx
< symtab_hdr
->sh_info
)
1818 /* A local symbol. */
1819 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1824 /* Check relocation against local STT_GNU_IFUNC symbol. */
1825 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1827 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1831 /* Fake a STT_GNU_IFUNC symbol. */
1832 h
->type
= STT_GNU_IFUNC
;
1835 h
->forced_local
= 1;
1836 h
->root
.type
= bfd_link_hash_defined
;
1844 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1845 while (h
->root
.type
== bfd_link_hash_indirect
1846 || h
->root
.type
== bfd_link_hash_warning
)
1847 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1850 eh
= (struct elf_i386_link_hash_entry
*) h
;
1865 if (htab
->elf
.dynobj
== NULL
)
1866 htab
->elf
.dynobj
= abfd
;
1867 /* Create the ifunc sections for static executables. */
1868 if (h
->type
== STT_GNU_IFUNC
1869 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1875 /* It is referenced by a non-shared object. */
1877 h
->root
.non_ir_ref
= 1;
1879 if (h
->type
== STT_GNU_IFUNC
)
1880 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1881 |= elf_gnu_symbol_ifunc
;
1884 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1885 symtab_hdr
, sym_hashes
,
1886 &r_type
, GOT_UNKNOWN
,
1887 rel
, rel_end
, h
, r_symndx
, FALSE
))
1893 htab
->tls_ldm_got
.refcount
+= 1;
1897 /* This symbol requires a procedure linkage table entry. We
1898 actually build the entry in adjust_dynamic_symbol,
1899 because this might be a case of linking PIC code which is
1900 never referenced by a dynamic object, in which case we
1901 don't need to generate a procedure linkage table entry
1904 /* If this is a local symbol, we resolve it directly without
1905 creating a procedure linkage table entry. */
1909 eh
->has_got_reloc
= 1;
1911 h
->plt
.refcount
+= 1;
1918 case R_386_TLS_IE_32
:
1920 case R_386_TLS_GOTIE
:
1921 if (!bfd_link_executable (info
))
1922 info
->flags
|= DF_STATIC_TLS
;
1928 case R_386_TLS_GOTDESC
:
1929 case R_386_TLS_DESC_CALL
:
1930 /* This symbol requires a global offset table entry. */
1932 int tls_type
, old_tls_type
;
1939 tls_type
= GOT_NORMAL
;
1941 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1942 case R_386_TLS_GOTDESC
:
1943 case R_386_TLS_DESC_CALL
:
1944 tls_type
= GOT_TLS_GDESC
; break;
1945 case R_386_TLS_IE_32
:
1946 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1947 tls_type
= GOT_TLS_IE_NEG
;
1949 /* If this is a GD->IE transition, we may use either of
1950 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1951 tls_type
= GOT_TLS_IE
;
1954 case R_386_TLS_GOTIE
:
1955 tls_type
= GOT_TLS_IE_POS
; break;
1960 h
->got
.refcount
+= 1;
1961 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1965 bfd_signed_vma
*local_got_refcounts
;
1967 /* This is a global offset table entry for a local symbol. */
1968 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1969 if (local_got_refcounts
== NULL
)
1973 size
= symtab_hdr
->sh_info
;
1974 size
*= (sizeof (bfd_signed_vma
)
1975 + sizeof (bfd_vma
) + sizeof(char));
1976 local_got_refcounts
= (bfd_signed_vma
*)
1977 bfd_zalloc (abfd
, size
);
1978 if (local_got_refcounts
== NULL
)
1980 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1981 elf_i386_local_tlsdesc_gotent (abfd
)
1982 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1983 elf_i386_local_got_tls_type (abfd
)
1984 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1986 local_got_refcounts
[r_symndx
] += 1;
1987 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1990 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1991 tls_type
|= old_tls_type
;
1992 /* If a TLS symbol is accessed using IE at least once,
1993 there is no point to use dynamic model for it. */
1994 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1995 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1996 || (tls_type
& GOT_TLS_IE
) == 0))
1998 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1999 tls_type
= old_tls_type
;
2000 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2001 && GOT_TLS_GD_ANY_P (tls_type
))
2002 tls_type
|= old_tls_type
;
2006 name
= h
->root
.root
.string
;
2008 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2010 (*_bfd_error_handler
)
2011 (_("%B: `%s' accessed both as normal and "
2012 "thread local symbol"),
2014 bfd_set_error (bfd_error_bad_value
);
2019 if (old_tls_type
!= tls_type
)
2022 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2024 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2032 if (htab
->elf
.sgot
== NULL
)
2034 if (htab
->elf
.dynobj
== NULL
)
2035 htab
->elf
.dynobj
= abfd
;
2036 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
2039 if (r_type
!= R_386_TLS_IE
)
2042 eh
->has_got_reloc
= 1;
2047 case R_386_TLS_LE_32
:
2050 eh
->has_got_reloc
= 1;
2051 if (bfd_link_executable (info
))
2053 info
->flags
|= DF_STATIC_TLS
;
2058 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2059 eh
->has_non_got_reloc
= 1;
2061 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2062 locally defined and undefined symbol may turn out to be
2063 a STT_GNU_IFUNC symbol later. */
2065 && (bfd_link_executable (info
)
2066 || ((h
->type
== STT_GNU_IFUNC
2067 || h
->root
.type
== bfd_link_hash_undefweak
2068 || h
->root
.type
== bfd_link_hash_undefined
)
2069 && SYMBOLIC_BIND (info
, h
))))
2071 /* If this reloc is in a read-only section, we might
2072 need a copy reloc. We can't check reliably at this
2073 stage whether the section is read-only, as input
2074 sections have not yet been mapped to output sections.
2075 Tentatively set the flag for now, and correct in
2076 adjust_dynamic_symbol. */
2079 /* We may need a .plt entry if the function this reloc
2080 refers to is in a shared lib. */
2081 h
->plt
.refcount
+= 1;
2082 if (r_type
== R_386_PC32
)
2084 /* Since something like ".long foo - ." may be used
2085 as pointer, make sure that PLT is used if foo is
2086 a function defined in a shared library. */
2087 if ((sec
->flags
& SEC_CODE
) == 0)
2088 h
->pointer_equality_needed
= 1;
2092 h
->pointer_equality_needed
= 1;
2093 /* R_386_32 can be resolved at run-time. */
2094 if (r_type
== R_386_32
2095 && (sec
->flags
& SEC_READONLY
) == 0)
2096 eh
->func_pointer_refcount
+= 1;
2102 /* If we are creating a shared library, and this is a reloc
2103 against a global symbol, or a non PC relative reloc
2104 against a local symbol, then we need to copy the reloc
2105 into the shared library. However, if we are linking with
2106 -Bsymbolic, we do not need to copy a reloc against a
2107 global symbol which is defined in an object we are
2108 including in the link (i.e., DEF_REGULAR is set). At
2109 this point we have not seen all the input files, so it is
2110 possible that DEF_REGULAR is not set now but will be set
2111 later (it is never cleared). In case of a weak definition,
2112 DEF_REGULAR may be cleared later by a strong definition in
2113 a shared library. We account for that possibility below by
2114 storing information in the relocs_copied field of the hash
2115 table entry. A similar situation occurs when creating
2116 shared libraries and symbol visibility changes render the
2119 If on the other hand, we are creating an executable, we
2120 may need to keep relocations for symbols satisfied by a
2121 dynamic library if we manage to avoid copy relocs for the
2123 if ((bfd_link_pic (info
)
2124 && (sec
->flags
& SEC_ALLOC
) != 0
2125 && (r_type
!= R_386_PC32
2127 && (! (bfd_link_pie (info
)
2128 || SYMBOLIC_BIND (info
, h
))
2129 || h
->root
.type
== bfd_link_hash_defweak
2130 || !h
->def_regular
))))
2131 || (ELIMINATE_COPY_RELOCS
2132 && !bfd_link_pic (info
)
2133 && (sec
->flags
& SEC_ALLOC
) != 0
2135 && (h
->root
.type
== bfd_link_hash_defweak
2136 || !h
->def_regular
)))
2138 struct elf_dyn_relocs
*p
;
2139 struct elf_dyn_relocs
**head
;
2141 /* We must copy these reloc types into the output file.
2142 Create a reloc section in dynobj and make room for
2146 if (htab
->elf
.dynobj
== NULL
)
2147 htab
->elf
.dynobj
= abfd
;
2149 sreloc
= _bfd_elf_make_dynamic_reloc_section
2150 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2156 /* If this is a global symbol, we count the number of
2157 relocations we need for this symbol. */
2160 head
= &eh
->dyn_relocs
;
2164 /* Track dynamic relocs needed for local syms too.
2165 We really need local syms available to do this
2170 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2175 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2179 vpp
= &elf_section_data (s
)->local_dynrel
;
2180 head
= (struct elf_dyn_relocs
**)vpp
;
2184 if (p
== NULL
|| p
->sec
!= sec
)
2186 bfd_size_type amt
= sizeof *p
;
2187 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2199 /* Count size relocation as PC-relative relocation. */
2200 if (r_type
== R_386_PC32
|| size_reloc
)
2205 /* This relocation describes the C++ object vtable hierarchy.
2206 Reconstruct it for later use during GC. */
2207 case R_386_GNU_VTINHERIT
:
2208 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2212 /* This relocation describes which C++ vtable entries are actually
2213 used. Record for later use during GC. */
2214 case R_386_GNU_VTENTRY
:
2215 BFD_ASSERT (h
!= NULL
);
2217 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2227 && h
->plt
.refcount
> 0
2228 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2229 || h
->got
.refcount
> 0)
2230 && htab
->plt_got
== NULL
)
2232 /* Create the GOT procedure linkage table. */
2233 unsigned int plt_got_align
;
2234 const struct elf_backend_data
*bed
;
2236 bed
= get_elf_backend_data (info
->output_bfd
);
2237 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
2238 && (sizeof (elf_i386_got_plt_entry
)
2239 == sizeof (elf_i386_pic_got_plt_entry
)));
2242 if (htab
->elf
.dynobj
== NULL
)
2243 htab
->elf
.dynobj
= abfd
;
2245 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2247 (bed
->dynamic_sec_flags
2252 if (htab
->plt_got
== NULL
2253 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2259 if (r_type
== R_386_GOT32X
2260 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2261 sec
->need_convert_load
= 1;
2264 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2266 if (!info
->keep_memory
)
2270 /* Cache the section contents for elf_link_input_bfd. */
2271 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2278 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2280 sec
->check_relocs_failed
= 1;
2284 /* Return the section that should be marked against GC for a given
2288 elf_i386_gc_mark_hook (asection
*sec
,
2289 struct bfd_link_info
*info
,
2290 Elf_Internal_Rela
*rel
,
2291 struct elf_link_hash_entry
*h
,
2292 Elf_Internal_Sym
*sym
)
2295 switch (ELF32_R_TYPE (rel
->r_info
))
2297 case R_386_GNU_VTINHERIT
:
2298 case R_386_GNU_VTENTRY
:
2302 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2305 /* Remove undefined weak symbol from the dynamic symbol table if it
2306 is resolved to 0. */
2309 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2310 struct elf_link_hash_entry
*h
)
2312 if (h
->dynindx
!= -1
2313 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2314 elf_i386_hash_entry (h
)->has_got_reloc
,
2315 elf_i386_hash_entry (h
)))
2318 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2324 /* Adjust a symbol defined by a dynamic object and referenced by a
2325 regular object. The current definition is in some section of the
2326 dynamic object, but we're not including those sections. We have to
2327 change the definition to something the rest of the link can
2331 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2332 struct elf_link_hash_entry
*h
)
2334 struct elf_i386_link_hash_table
*htab
;
2336 struct elf_i386_link_hash_entry
*eh
;
2337 struct elf_dyn_relocs
*p
;
2339 /* STT_GNU_IFUNC symbol must go through PLT. */
2340 if (h
->type
== STT_GNU_IFUNC
)
2342 /* All local STT_GNU_IFUNC references must be treate as local
2343 calls via local PLT. */
2345 && SYMBOL_CALLS_LOCAL (info
, h
))
2347 bfd_size_type pc_count
= 0, count
= 0;
2348 struct elf_dyn_relocs
**pp
;
2350 eh
= (struct elf_i386_link_hash_entry
*) h
;
2351 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2353 pc_count
+= p
->pc_count
;
2354 p
->count
-= p
->pc_count
;
2363 if (pc_count
|| count
)
2367 if (h
->plt
.refcount
<= 0)
2368 h
->plt
.refcount
= 1;
2370 h
->plt
.refcount
+= 1;
2374 if (h
->plt
.refcount
<= 0)
2376 h
->plt
.offset
= (bfd_vma
) -1;
2382 /* If this is a function, put it in the procedure linkage table. We
2383 will fill in the contents of the procedure linkage table later,
2384 when we know the address of the .got section. */
2385 if (h
->type
== STT_FUNC
2388 if (h
->plt
.refcount
<= 0
2389 || SYMBOL_CALLS_LOCAL (info
, h
)
2390 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2391 && h
->root
.type
== bfd_link_hash_undefweak
))
2393 /* This case can occur if we saw a PLT32 reloc in an input
2394 file, but the symbol was never referred to by a dynamic
2395 object, or if all references were garbage collected. In
2396 such a case, we don't actually need to build a procedure
2397 linkage table, and we can just do a PC32 reloc instead. */
2398 h
->plt
.offset
= (bfd_vma
) -1;
2405 /* It's possible that we incorrectly decided a .plt reloc was
2406 needed for an R_386_PC32 reloc to a non-function sym in
2407 check_relocs. We can't decide accurately between function and
2408 non-function syms in check-relocs; Objects loaded later in
2409 the link may change h->type. So fix it now. */
2410 h
->plt
.offset
= (bfd_vma
) -1;
2412 /* If this is a weak symbol, and there is a real definition, the
2413 processor independent code will have arranged for us to see the
2414 real definition first, and we can just use the same value. */
2415 if (h
->u
.weakdef
!= NULL
)
2417 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2418 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2419 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2420 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2421 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2422 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2426 /* This is a reference to a symbol defined by a dynamic object which
2427 is not a function. */
2429 /* If we are creating a shared library, we must presume that the
2430 only references to the symbol are via the global offset table.
2431 For such cases we need not do anything here; the relocations will
2432 be handled correctly by relocate_section. */
2433 if (!bfd_link_executable (info
))
2436 /* If there are no references to this symbol that do not use the
2437 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2439 eh
= (struct elf_i386_link_hash_entry
*) h
;
2440 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2443 /* If -z nocopyreloc was given, we won't generate them either. */
2444 if (info
->nocopyreloc
)
2450 htab
= elf_i386_hash_table (info
);
2454 /* If there aren't any dynamic relocs in read-only sections nor
2455 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2456 avoid the copy reloc. This doesn't work on VxWorks, where we can
2457 not have dynamic relocations (other than copy and jump slot
2458 relocations) in an executable. */
2459 if (ELIMINATE_COPY_RELOCS
2461 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2463 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2465 s
= p
->sec
->output_section
;
2466 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2477 /* We must allocate the symbol in our .dynbss section, which will
2478 become part of the .bss section of the executable. There will be
2479 an entry for this symbol in the .dynsym section. The dynamic
2480 object will contain position independent code, so all references
2481 from the dynamic object to this symbol will go through the global
2482 offset table. The dynamic linker will use the .dynsym entry to
2483 determine the address it must put in the global offset table, so
2484 both the dynamic object and the regular object will refer to the
2485 same memory location for the variable. */
2487 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2488 copy the initial value out of the dynamic object and into the
2489 runtime process image. */
2490 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2492 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2498 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2501 /* Allocate space in .plt, .got and associated reloc sections for
2505 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2507 struct bfd_link_info
*info
;
2508 struct elf_i386_link_hash_table
*htab
;
2509 struct elf_i386_link_hash_entry
*eh
;
2510 struct elf_dyn_relocs
*p
;
2511 unsigned plt_entry_size
;
2512 bfd_boolean resolved_to_zero
;
2514 if (h
->root
.type
== bfd_link_hash_indirect
)
2517 eh
= (struct elf_i386_link_hash_entry
*) h
;
2519 info
= (struct bfd_link_info
*) inf
;
2520 htab
= elf_i386_hash_table (info
);
2524 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2526 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2530 /* Clear the reference count of function pointer relocations if
2531 symbol isn't a normal function. */
2532 if (h
->type
!= STT_FUNC
)
2533 eh
->func_pointer_refcount
= 0;
2535 /* We can't use the GOT PLT if pointer equality is needed since
2536 finish_dynamic_symbol won't clear symbol value and the dynamic
2537 linker won't update the GOT slot. We will get into an infinite
2538 loop at run-time. */
2539 if (htab
->plt_got
!= NULL
2540 && h
->type
!= STT_GNU_IFUNC
2541 && !h
->pointer_equality_needed
2542 && h
->plt
.refcount
> 0
2543 && h
->got
.refcount
> 0)
2545 /* Don't use the regular PLT if there are both GOT and GOTPLT
2547 h
->plt
.offset
= (bfd_vma
) -1;
2549 /* Use the GOT PLT. */
2550 eh
->plt_got
.refcount
= 1;
2553 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2554 here if it is defined and referenced in a non-shared object. */
2555 if (h
->type
== STT_GNU_IFUNC
2557 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2558 &htab
->readonly_dynrelocs_against_ifunc
,
2561 /* Don't create the PLT entry if there are only function pointer
2562 relocations which can be resolved at run-time. */
2563 else if (htab
->elf
.dynamic_sections_created
2564 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2565 || eh
->plt_got
.refcount
> 0))
2567 bfd_boolean use_plt_got
;
2569 /* Clear the reference count of function pointer relocations
2571 eh
->func_pointer_refcount
= 0;
2573 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2575 /* Don't use the regular PLT for DF_BIND_NOW. */
2576 h
->plt
.offset
= (bfd_vma
) -1;
2578 /* Use the GOT PLT. */
2579 h
->got
.refcount
= 1;
2580 eh
->plt_got
.refcount
= 1;
2583 use_plt_got
= eh
->plt_got
.refcount
> 0;
2585 /* Make sure this symbol is output as a dynamic symbol.
2586 Undefined weak syms won't yet be marked as dynamic. */
2587 if (h
->dynindx
== -1
2589 && !resolved_to_zero
)
2591 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2595 if (bfd_link_pic (info
)
2596 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2598 asection
*s
= htab
->elf
.splt
;
2599 asection
*got_s
= htab
->plt_got
;
2601 /* If this is the first .plt entry, make room for the special
2602 first entry. The .plt section is used by prelink to undo
2603 prelinking for dynamic relocations. */
2605 s
->size
= plt_entry_size
;
2608 eh
->plt_got
.offset
= got_s
->size
;
2610 h
->plt
.offset
= s
->size
;
2612 /* If this symbol is not defined in a regular file, and we are
2613 not generating a shared library, then set the symbol to this
2614 location in the .plt. This is required to make function
2615 pointers compare as equal between the normal executable and
2616 the shared library. */
2617 if (! bfd_link_pic (info
)
2622 /* We need to make a call to the entry of the GOT PLT
2623 instead of regular PLT entry. */
2624 h
->root
.u
.def
.section
= got_s
;
2625 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2629 h
->root
.u
.def
.section
= s
;
2630 h
->root
.u
.def
.value
= h
->plt
.offset
;
2634 /* Make room for this entry. */
2636 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2639 s
->size
+= plt_entry_size
;
2641 /* We also need to make an entry in the .got.plt section,
2642 which will be placed in the .got section by the linker
2644 htab
->elf
.sgotplt
->size
+= 4;
2646 /* There should be no PLT relocation against resolved
2647 undefined weak symbol in executable. */
2648 if (!resolved_to_zero
)
2650 /* We also need to make an entry in the .rel.plt
2652 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2653 htab
->elf
.srelplt
->reloc_count
++;
2657 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2658 && !bfd_link_pic (info
))
2660 /* VxWorks has a second set of relocations for each PLT entry
2661 in executables. They go in a separate relocation section,
2662 which is processed by the kernel loader. */
2664 /* There are two relocations for the initial PLT entry: an
2665 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2666 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2668 if (h
->plt
.offset
== plt_entry_size
)
2669 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2671 /* There are two extra relocations for each subsequent PLT entry:
2672 an R_386_32 relocation for the GOT entry, and an R_386_32
2673 relocation for the PLT entry. */
2675 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2680 eh
->plt_got
.offset
= (bfd_vma
) -1;
2681 h
->plt
.offset
= (bfd_vma
) -1;
2687 eh
->plt_got
.offset
= (bfd_vma
) -1;
2688 h
->plt
.offset
= (bfd_vma
) -1;
2692 eh
->tlsdesc_got
= (bfd_vma
) -1;
2694 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2695 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2696 if (h
->got
.refcount
> 0
2697 && bfd_link_executable (info
)
2699 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2700 h
->got
.offset
= (bfd_vma
) -1;
2701 else if (h
->got
.refcount
> 0)
2705 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2707 /* Make sure this symbol is output as a dynamic symbol.
2708 Undefined weak syms won't yet be marked as dynamic. */
2709 if (h
->dynindx
== -1
2711 && !resolved_to_zero
)
2713 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2718 if (GOT_TLS_GDESC_P (tls_type
))
2720 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2721 - elf_i386_compute_jump_table_size (htab
);
2722 htab
->elf
.sgotplt
->size
+= 8;
2723 h
->got
.offset
= (bfd_vma
) -2;
2725 if (! GOT_TLS_GDESC_P (tls_type
)
2726 || GOT_TLS_GD_P (tls_type
))
2728 h
->got
.offset
= s
->size
;
2730 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2731 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2734 dyn
= htab
->elf
.dynamic_sections_created
;
2735 /* R_386_TLS_IE_32 needs one dynamic relocation,
2736 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2737 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2738 need two), R_386_TLS_GD needs one if local symbol and two if
2739 global. No dynamic relocation against resolved undefined weak
2740 symbol in executable. */
2741 if (tls_type
== GOT_TLS_IE_BOTH
)
2742 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2743 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2744 || (tls_type
& GOT_TLS_IE
))
2745 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2746 else if (GOT_TLS_GD_P (tls_type
))
2747 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2748 else if (! GOT_TLS_GDESC_P (tls_type
)
2749 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2750 && !resolved_to_zero
)
2751 || h
->root
.type
!= bfd_link_hash_undefweak
)
2752 && (bfd_link_pic (info
)
2753 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2754 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2755 if (GOT_TLS_GDESC_P (tls_type
))
2756 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2759 h
->got
.offset
= (bfd_vma
) -1;
2761 if (eh
->dyn_relocs
== NULL
)
2764 /* In the shared -Bsymbolic case, discard space allocated for
2765 dynamic pc-relative relocs against symbols which turn out to be
2766 defined in regular objects. For the normal shared case, discard
2767 space for pc-relative relocs that have become local due to symbol
2768 visibility changes. */
2770 if (bfd_link_pic (info
))
2772 /* The only reloc that uses pc_count is R_386_PC32, which will
2773 appear on a call or on something like ".long foo - .". We
2774 want calls to protected symbols to resolve directly to the
2775 function rather than going via the plt. If people want
2776 function pointer comparisons to work as expected then they
2777 should avoid writing assembly like ".long foo - .". */
2778 if (SYMBOL_CALLS_LOCAL (info
, h
))
2780 struct elf_dyn_relocs
**pp
;
2782 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2784 p
->count
-= p
->pc_count
;
2793 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2795 struct elf_dyn_relocs
**pp
;
2796 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2798 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2805 /* Also discard relocs on undefined weak syms with non-default
2806 visibility or in PIE. */
2807 if (eh
->dyn_relocs
!= NULL
2808 && h
->root
.type
== bfd_link_hash_undefweak
)
2810 /* Undefined weak symbol is never bound locally in shared
2812 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2813 || resolved_to_zero
)
2817 /* Keep dynamic non-GOT/non-PLT relocation so that we
2818 can branch to 0 without PLT. */
2819 struct elf_dyn_relocs
**pp
;
2821 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2822 if (p
->pc_count
== 0)
2826 /* Remove non-R_386_PC32 relocation. */
2827 p
->count
= p
->pc_count
;
2831 if (eh
->dyn_relocs
!= NULL
)
2833 /* Make sure undefined weak symbols are output
2834 as dynamic symbols in PIEs for dynamic non-GOT
2835 non-PLT reloations. */
2836 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2841 eh
->dyn_relocs
= NULL
;
2843 else if (h
->dynindx
== -1
2844 && !h
->forced_local
)
2846 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2851 else if (ELIMINATE_COPY_RELOCS
)
2853 /* For the non-shared case, discard space for relocs against
2854 symbols which turn out to need copy relocs or are not
2855 dynamic. Keep dynamic relocations for run-time function
2856 pointer initialization. */
2858 if ((!h
->non_got_ref
2859 || eh
->func_pointer_refcount
> 0
2860 || (h
->root
.type
== bfd_link_hash_undefweak
2861 && !resolved_to_zero
))
2864 || (htab
->elf
.dynamic_sections_created
2865 && (h
->root
.type
== bfd_link_hash_undefweak
2866 || h
->root
.type
== bfd_link_hash_undefined
))))
2868 /* Make sure this symbol is output as a dynamic symbol.
2869 Undefined weak syms won't yet be marked as dynamic. */
2870 if (h
->dynindx
== -1
2872 && !resolved_to_zero
)
2874 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2878 /* If that succeeded, we know we'll be keeping all the
2880 if (h
->dynindx
!= -1)
2884 eh
->dyn_relocs
= NULL
;
2885 eh
->func_pointer_refcount
= 0;
2890 /* Finally, allocate space. */
2891 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2895 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2897 BFD_ASSERT (sreloc
!= NULL
);
2898 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2904 /* Allocate space in .plt, .got and associated reloc sections for
2905 local dynamic relocs. */
2908 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2910 struct elf_link_hash_entry
*h
2911 = (struct elf_link_hash_entry
*) *slot
;
2913 if (h
->type
!= STT_GNU_IFUNC
2917 || h
->root
.type
!= bfd_link_hash_defined
)
2920 return elf_i386_allocate_dynrelocs (h
, inf
);
2923 /* Find any dynamic relocs that apply to read-only sections. */
2926 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2928 struct elf_i386_link_hash_entry
*eh
;
2929 struct elf_dyn_relocs
*p
;
2931 /* Skip local IFUNC symbols. */
2932 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2935 eh
= (struct elf_i386_link_hash_entry
*) h
;
2936 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2938 asection
*s
= p
->sec
->output_section
;
2940 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2942 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2944 info
->flags
|= DF_TEXTREL
;
2946 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2947 || info
->error_textrel
)
2948 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2949 p
->sec
->owner
, h
->root
.root
.string
,
2952 /* Not an error, just cut short the traversal. */
2959 /* Convert load via the GOT slot to load immediate. */
2962 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
2963 struct bfd_link_info
*link_info
)
2965 struct elf_i386_link_hash_table
*htab
;
2966 Elf_Internal_Shdr
*symtab_hdr
;
2967 Elf_Internal_Rela
*internal_relocs
;
2968 Elf_Internal_Rela
*irel
, *irelend
;
2970 bfd_boolean changed
;
2971 bfd_signed_vma
*local_got_refcounts
;
2973 /* Don't even try to convert non-ELF outputs. */
2974 if (!is_elf_hash_table (link_info
->hash
))
2977 /* Nothing to do if there is no need or no output. */
2978 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2979 || sec
->need_convert_load
== 0
2980 || bfd_is_abs_section (sec
->output_section
))
2983 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2985 /* Load the relocations for this section. */
2986 internal_relocs
= (_bfd_elf_link_read_relocs
2987 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2988 link_info
->keep_memory
));
2989 if (internal_relocs
== NULL
)
2993 htab
= elf_i386_hash_table (link_info
);
2994 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2996 /* Get the section contents. */
2997 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2998 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3001 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3005 irelend
= internal_relocs
+ sec
->reloc_count
;
3006 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3008 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3009 unsigned int r_symndx
;
3010 struct elf_link_hash_entry
*h
;
3011 bfd_boolean converted
;
3013 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3014 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3015 if (r_type
!= R_386_GOT32X
)
3018 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3019 if (r_symndx
< symtab_hdr
->sh_info
)
3020 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3021 (const Elf_Internal_Rela
*) irel
,
3025 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3026 while (h
->root
.type
== bfd_link_hash_indirect
3027 || h
->root
.type
== bfd_link_hash_warning
)
3028 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3031 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3032 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3036 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3037 irel
, h
, &converted
, link_info
))
3042 changed
= converted
;
3045 if (h
->got
.refcount
> 0)
3046 h
->got
.refcount
-= 1;
3050 if (local_got_refcounts
!= NULL
3051 && local_got_refcounts
[r_symndx
] > 0)
3052 local_got_refcounts
[r_symndx
] -= 1;
3057 if (contents
!= NULL
3058 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3060 if (!changed
&& !link_info
->keep_memory
)
3064 /* Cache the section contents for elf_link_input_bfd. */
3065 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3069 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3072 free (internal_relocs
);
3074 elf_section_data (sec
)->relocs
= internal_relocs
;
3080 if (contents
!= NULL
3081 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3083 if (internal_relocs
!= NULL
3084 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3085 free (internal_relocs
);
3089 /* Set the sizes of the dynamic sections. */
3092 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3094 struct elf_i386_link_hash_table
*htab
;
3100 htab
= elf_i386_hash_table (info
);
3103 dynobj
= htab
->elf
.dynobj
;
3107 /* Set up .got offsets for local syms, and space for local dynamic
3109 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3111 bfd_signed_vma
*local_got
;
3112 bfd_signed_vma
*end_local_got
;
3113 char *local_tls_type
;
3114 bfd_vma
*local_tlsdesc_gotent
;
3115 bfd_size_type locsymcount
;
3116 Elf_Internal_Shdr
*symtab_hdr
;
3119 if (! is_i386_elf (ibfd
))
3122 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3124 struct elf_dyn_relocs
*p
;
3126 if (!elf_i386_convert_load (ibfd
, s
, info
))
3129 for (p
= ((struct elf_dyn_relocs
*)
3130 elf_section_data (s
)->local_dynrel
);
3134 if (!bfd_is_abs_section (p
->sec
)
3135 && bfd_is_abs_section (p
->sec
->output_section
))
3137 /* Input section has been discarded, either because
3138 it is a copy of a linkonce section or due to
3139 linker script /DISCARD/, so we'll be discarding
3142 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3143 && strcmp (p
->sec
->output_section
->name
,
3146 /* Relocations in vxworks .tls_vars sections are
3147 handled specially by the loader. */
3149 else if (p
->count
!= 0)
3151 srel
= elf_section_data (p
->sec
)->sreloc
;
3152 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3153 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3154 && (info
->flags
& DF_TEXTREL
) == 0)
3156 info
->flags
|= DF_TEXTREL
;
3157 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3158 || info
->error_textrel
)
3159 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3160 p
->sec
->owner
, p
->sec
);
3166 local_got
= elf_local_got_refcounts (ibfd
);
3170 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3171 locsymcount
= symtab_hdr
->sh_info
;
3172 end_local_got
= local_got
+ locsymcount
;
3173 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3174 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3176 srel
= htab
->elf
.srelgot
;
3177 for (; local_got
< end_local_got
;
3178 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3180 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3183 if (GOT_TLS_GDESC_P (*local_tls_type
))
3185 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3186 - elf_i386_compute_jump_table_size (htab
);
3187 htab
->elf
.sgotplt
->size
+= 8;
3188 *local_got
= (bfd_vma
) -2;
3190 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3191 || GOT_TLS_GD_P (*local_tls_type
))
3193 *local_got
= s
->size
;
3195 if (GOT_TLS_GD_P (*local_tls_type
)
3196 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3199 if (bfd_link_pic (info
)
3200 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3201 || (*local_tls_type
& GOT_TLS_IE
))
3203 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3204 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3205 else if (GOT_TLS_GD_P (*local_tls_type
)
3206 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3207 srel
->size
+= sizeof (Elf32_External_Rel
);
3208 if (GOT_TLS_GDESC_P (*local_tls_type
))
3209 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3213 *local_got
= (bfd_vma
) -1;
3217 if (htab
->tls_ldm_got
.refcount
> 0)
3219 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3221 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3222 htab
->elf
.sgot
->size
+= 8;
3223 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3226 htab
->tls_ldm_got
.offset
= -1;
3228 /* Allocate global sym .plt and .got entries, and space for global
3229 sym dynamic relocs. */
3230 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3232 /* Allocate .plt and .got entries, and space for local symbols. */
3233 htab_traverse (htab
->loc_hash_table
,
3234 elf_i386_allocate_local_dynrelocs
,
3237 /* For every jump slot reserved in the sgotplt, reloc_count is
3238 incremented. However, when we reserve space for TLS descriptors,
3239 it's not incremented, so in order to compute the space reserved
3240 for them, it suffices to multiply the reloc count by the jump
3243 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3244 so that R_386_IRELATIVE entries come last. */
3245 if (htab
->elf
.srelplt
)
3247 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3248 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3249 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3251 else if (htab
->elf
.irelplt
)
3252 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3255 if (htab
->elf
.sgotplt
)
3257 /* Don't allocate .got.plt section if there are no GOT nor PLT
3258 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3259 if ((htab
->elf
.hgot
== NULL
3260 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3261 && (htab
->elf
.sgotplt
->size
3262 == get_elf_backend_data (output_bfd
)->got_header_size
)
3263 && (htab
->elf
.splt
== NULL
3264 || htab
->elf
.splt
->size
== 0)
3265 && (htab
->elf
.sgot
== NULL
3266 || htab
->elf
.sgot
->size
== 0)
3267 && (htab
->elf
.iplt
== NULL
3268 || htab
->elf
.iplt
->size
== 0)
3269 && (htab
->elf
.igotplt
== NULL
3270 || htab
->elf
.igotplt
->size
== 0))
3271 htab
->elf
.sgotplt
->size
= 0;
3275 if (htab
->plt_eh_frame
!= NULL
3276 && htab
->elf
.splt
!= NULL
3277 && htab
->elf
.splt
->size
!= 0
3278 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3279 && _bfd_elf_eh_frame_present (info
))
3280 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3282 /* We now have determined the sizes of the various dynamic sections.
3283 Allocate memory for them. */
3285 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3287 bfd_boolean strip_section
= TRUE
;
3289 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3292 if (s
== htab
->elf
.splt
3293 || s
== htab
->elf
.sgot
)
3295 /* Strip this section if we don't need it; see the
3297 /* We'd like to strip these sections if they aren't needed, but if
3298 we've exported dynamic symbols from them we must leave them.
3299 It's too late to tell BFD to get rid of the symbols. */
3301 if (htab
->elf
.hplt
!= NULL
)
3302 strip_section
= FALSE
;
3304 else if (s
== htab
->elf
.sgotplt
3305 || s
== htab
->elf
.iplt
3306 || s
== htab
->elf
.igotplt
3307 || s
== htab
->plt_got
3308 || s
== htab
->plt_eh_frame
3309 || s
== htab
->sdynbss
)
3311 /* Strip these too. */
3313 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3316 && s
!= htab
->elf
.srelplt
3317 && s
!= htab
->srelplt2
)
3320 /* We use the reloc_count field as a counter if we need
3321 to copy relocs into the output file. */
3326 /* It's not one of our sections, so don't allocate space. */
3332 /* If we don't need this section, strip it from the
3333 output file. This is mostly to handle .rel.bss and
3334 .rel.plt. We must create both sections in
3335 create_dynamic_sections, because they must be created
3336 before the linker maps input sections to output
3337 sections. The linker does that before
3338 adjust_dynamic_symbol is called, and it is that
3339 function which decides whether anything needs to go
3340 into these sections. */
3342 s
->flags
|= SEC_EXCLUDE
;
3346 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3349 /* Allocate memory for the section contents. We use bfd_zalloc
3350 here in case unused entries are not reclaimed before the
3351 section's contents are written out. This should not happen,
3352 but this way if it does, we get a R_386_NONE reloc instead
3354 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3355 if (s
->contents
== NULL
)
3359 if (htab
->plt_eh_frame
!= NULL
3360 && htab
->plt_eh_frame
->contents
!= NULL
)
3362 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3363 sizeof (elf_i386_eh_frame_plt
));
3364 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3365 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3368 if (htab
->elf
.dynamic_sections_created
)
3370 /* Add some entries to the .dynamic section. We fill in the
3371 values later, in elf_i386_finish_dynamic_sections, but we
3372 must add the entries now so that we get the correct size for
3373 the .dynamic section. The DT_DEBUG entry is filled in by the
3374 dynamic linker and used by the debugger. */
3375 #define add_dynamic_entry(TAG, VAL) \
3376 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3378 if (bfd_link_executable (info
))
3380 if (!add_dynamic_entry (DT_DEBUG
, 0))
3384 if (htab
->elf
.splt
->size
!= 0)
3386 /* DT_PLTGOT is used by prelink even if there is no PLT
3388 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3391 if (htab
->elf
.srelplt
->size
!= 0)
3393 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3394 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3395 || !add_dynamic_entry (DT_JMPREL
, 0))
3402 if (!add_dynamic_entry (DT_REL
, 0)
3403 || !add_dynamic_entry (DT_RELSZ
, 0)
3404 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3407 /* If any dynamic relocs apply to a read-only section,
3408 then we need a DT_TEXTREL entry. */
3409 if ((info
->flags
& DF_TEXTREL
) == 0)
3410 elf_link_hash_traverse (&htab
->elf
,
3411 elf_i386_readonly_dynrelocs
, info
);
3413 if ((info
->flags
& DF_TEXTREL
) != 0)
3415 if (htab
->readonly_dynrelocs_against_ifunc
)
3417 info
->callbacks
->einfo
3418 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3419 bfd_set_error (bfd_error_bad_value
);
3423 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3427 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3428 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3431 #undef add_dynamic_entry
3437 elf_i386_always_size_sections (bfd
*output_bfd
,
3438 struct bfd_link_info
*info
)
3440 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3444 struct elf_link_hash_entry
*tlsbase
;
3446 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3447 "_TLS_MODULE_BASE_",
3448 FALSE
, FALSE
, FALSE
);
3450 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3452 struct elf_i386_link_hash_table
*htab
;
3453 struct bfd_link_hash_entry
*bh
= NULL
;
3454 const struct elf_backend_data
*bed
3455 = get_elf_backend_data (output_bfd
);
3457 htab
= elf_i386_hash_table (info
);
3461 if (!(_bfd_generic_link_add_one_symbol
3462 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3463 tls_sec
, 0, NULL
, FALSE
,
3464 bed
->collect
, &bh
)))
3467 htab
->tls_module_base
= bh
;
3469 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3470 tlsbase
->def_regular
= 1;
3471 tlsbase
->other
= STV_HIDDEN
;
3472 tlsbase
->root
.linker_def
= 1;
3473 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3480 /* Set the correct type for an x86 ELF section. We do this by the
3481 section name, which is a hack, but ought to work. */
3484 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3485 Elf_Internal_Shdr
*hdr
,
3490 name
= bfd_get_section_name (abfd
, sec
);
3492 /* This is an ugly, but unfortunately necessary hack that is
3493 needed when producing EFI binaries on x86. It tells
3494 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3495 containing ELF relocation info. We need this hack in order to
3496 be able to generate ELF binaries that can be translated into
3497 EFI applications (which are essentially COFF objects). Those
3498 files contain a COFF ".reloc" section inside an ELFNN object,
3499 which would normally cause BFD to segfault because it would
3500 attempt to interpret this section as containing relocation
3501 entries for section "oc". With this hack enabled, ".reloc"
3502 will be treated as a normal data section, which will avoid the
3503 segfault. However, you won't be able to create an ELFNN binary
3504 with a section named "oc" that needs relocations, but that's
3505 the kind of ugly side-effects you get when detecting section
3506 types based on their names... In practice, this limitation is
3507 unlikely to bite. */
3508 if (strcmp (name
, ".reloc") == 0)
3509 hdr
->sh_type
= SHT_PROGBITS
;
3514 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3515 executables. Rather than setting it to the beginning of the TLS
3516 section, we have to set it to the end. This function may be called
3517 multiple times, it is idempotent. */
3520 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3522 struct elf_i386_link_hash_table
*htab
;
3523 struct bfd_link_hash_entry
*base
;
3525 if (!bfd_link_executable (info
))
3528 htab
= elf_i386_hash_table (info
);
3532 base
= htab
->tls_module_base
;
3536 base
->u
.def
.value
= htab
->elf
.tls_size
;
3539 /* Return the base VMA address which should be subtracted from real addresses
3540 when resolving @dtpoff relocation.
3541 This is PT_TLS segment p_vaddr. */
3544 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3546 /* If tls_sec is NULL, we should have signalled an error already. */
3547 if (elf_hash_table (info
)->tls_sec
== NULL
)
3549 return elf_hash_table (info
)->tls_sec
->vma
;
3552 /* Return the relocation value for @tpoff relocation
3553 if STT_TLS virtual address is ADDRESS. */
3556 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3558 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3559 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3560 bfd_vma static_tls_size
;
3562 /* If tls_sec is NULL, we should have signalled an error already. */
3563 if (htab
->tls_sec
== NULL
)
3566 /* Consider special static TLS alignment requirements. */
3567 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3568 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3571 /* Relocate an i386 ELF section. */
3574 elf_i386_relocate_section (bfd
*output_bfd
,
3575 struct bfd_link_info
*info
,
3577 asection
*input_section
,
3579 Elf_Internal_Rela
*relocs
,
3580 Elf_Internal_Sym
*local_syms
,
3581 asection
**local_sections
)
3583 struct elf_i386_link_hash_table
*htab
;
3584 Elf_Internal_Shdr
*symtab_hdr
;
3585 struct elf_link_hash_entry
**sym_hashes
;
3586 bfd_vma
*local_got_offsets
;
3587 bfd_vma
*local_tlsdesc_gotents
;
3588 Elf_Internal_Rela
*rel
;
3589 Elf_Internal_Rela
*wrel
;
3590 Elf_Internal_Rela
*relend
;
3591 bfd_boolean is_vxworks_tls
;
3592 unsigned plt_entry_size
;
3594 BFD_ASSERT (is_i386_elf (input_bfd
));
3596 /* Skip if check_relocs failed. */
3597 if (input_section
->check_relocs_failed
)
3600 htab
= elf_i386_hash_table (info
);
3603 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3604 sym_hashes
= elf_sym_hashes (input_bfd
);
3605 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3606 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3607 /* We have to handle relocations in vxworks .tls_vars sections
3608 specially, because the dynamic loader is 'weird'. */
3609 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3610 && bfd_link_pic (info
)
3611 && !strcmp (input_section
->output_section
->name
,
3614 elf_i386_set_tls_module_base (info
);
3616 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3618 rel
= wrel
= relocs
;
3619 relend
= relocs
+ input_section
->reloc_count
;
3620 for (; rel
< relend
; wrel
++, rel
++)
3622 unsigned int r_type
;
3623 reloc_howto_type
*howto
;
3624 unsigned long r_symndx
;
3625 struct elf_link_hash_entry
*h
;
3626 struct elf_i386_link_hash_entry
*eh
;
3627 Elf_Internal_Sym
*sym
;
3629 bfd_vma off
, offplt
, plt_offset
;
3631 bfd_boolean unresolved_reloc
;
3632 bfd_reloc_status_type r
;
3636 asection
*resolved_plt
;
3637 bfd_boolean resolved_to_zero
;
3639 r_type
= ELF32_R_TYPE (rel
->r_info
);
3640 if (r_type
== R_386_GNU_VTINHERIT
3641 || r_type
== R_386_GNU_VTENTRY
)
3648 if ((indx
= r_type
) >= R_386_standard
3649 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3650 >= R_386_ext
- R_386_standard
)
3651 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3652 >= R_386_ext2
- R_386_ext
))
3654 (*_bfd_error_handler
)
3655 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3656 input_bfd
, input_section
, r_type
);
3657 bfd_set_error (bfd_error_bad_value
);
3660 howto
= elf_howto_table
+ indx
;
3662 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3666 unresolved_reloc
= FALSE
;
3667 if (r_symndx
< symtab_hdr
->sh_info
)
3669 sym
= local_syms
+ r_symndx
;
3670 sec
= local_sections
[r_symndx
];
3671 relocation
= (sec
->output_section
->vma
3672 + sec
->output_offset
3674 st_size
= sym
->st_size
;
3676 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3677 && ((sec
->flags
& SEC_MERGE
) != 0
3678 || (bfd_link_relocatable (info
)
3679 && sec
->output_offset
!= 0)))
3682 bfd_byte
*where
= contents
+ rel
->r_offset
;
3684 switch (howto
->size
)
3687 addend
= bfd_get_8 (input_bfd
, where
);
3688 if (howto
->pc_relative
)
3690 addend
= (addend
^ 0x80) - 0x80;
3695 addend
= bfd_get_16 (input_bfd
, where
);
3696 if (howto
->pc_relative
)
3698 addend
= (addend
^ 0x8000) - 0x8000;
3703 addend
= bfd_get_32 (input_bfd
, where
);
3704 if (howto
->pc_relative
)
3706 addend
= (addend
^ 0x80000000) - 0x80000000;
3714 if (bfd_link_relocatable (info
))
3715 addend
+= sec
->output_offset
;
3718 asection
*msec
= sec
;
3719 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3721 addend
-= relocation
;
3722 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3725 switch (howto
->size
)
3728 /* FIXME: overflow checks. */
3729 if (howto
->pc_relative
)
3731 bfd_put_8 (input_bfd
, addend
, where
);
3734 if (howto
->pc_relative
)
3736 bfd_put_16 (input_bfd
, addend
, where
);
3739 if (howto
->pc_relative
)
3741 bfd_put_32 (input_bfd
, addend
, where
);
3745 else if (!bfd_link_relocatable (info
)
3746 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3748 /* Relocate against local STT_GNU_IFUNC symbol. */
3749 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3754 /* Set STT_GNU_IFUNC symbol value. */
3755 h
->root
.u
.def
.value
= sym
->st_value
;
3756 h
->root
.u
.def
.section
= sec
;
3761 bfd_boolean warned ATTRIBUTE_UNUSED
;
3762 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3764 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3765 r_symndx
, symtab_hdr
, sym_hashes
,
3767 unresolved_reloc
, warned
, ignored
);
3771 if (sec
!= NULL
&& discarded_section (sec
))
3773 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3774 contents
+ rel
->r_offset
);
3775 wrel
->r_offset
= rel
->r_offset
;
3779 /* For ld -r, remove relocations in debug sections against
3780 sections defined in discarded sections. Not done for
3781 eh_frame editing code expects to be present. */
3782 if (bfd_link_relocatable (info
)
3783 && (input_section
->flags
& SEC_DEBUGGING
))
3789 if (bfd_link_relocatable (info
))
3796 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3797 it here if it is defined in a non-shared object. */
3799 && h
->type
== STT_GNU_IFUNC
3802 asection
*plt
, *gotplt
, *base_got
;
3806 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3808 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3809 sections because such sections are not SEC_ALLOC and
3810 thus ld.so will not process them. */
3811 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3815 else if (h
->plt
.offset
== (bfd_vma
) -1)
3818 /* STT_GNU_IFUNC symbol must go through PLT. */
3819 if (htab
->elf
.splt
!= NULL
)
3821 plt
= htab
->elf
.splt
;
3822 gotplt
= htab
->elf
.sgotplt
;
3826 plt
= htab
->elf
.iplt
;
3827 gotplt
= htab
->elf
.igotplt
;
3830 relocation
= (plt
->output_section
->vma
3831 + plt
->output_offset
+ h
->plt
.offset
);
3836 if (h
->root
.root
.string
)
3837 name
= h
->root
.root
.string
;
3839 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3841 (*_bfd_error_handler
)
3842 (_("%B: relocation %s against STT_GNU_IFUNC "
3843 "symbol `%s' isn't handled by %s"), input_bfd
,
3844 elf_howto_table
[r_type
].name
,
3845 name
, __FUNCTION__
);
3846 bfd_set_error (bfd_error_bad_value
);
3850 /* Generate dynamic relcoation only when there is a
3851 non-GOT reference in a shared object. */
3852 if (bfd_link_pic (info
) && h
->non_got_ref
)
3854 Elf_Internal_Rela outrel
;
3858 /* Need a dynamic relocation to get the real function
3860 offset
= _bfd_elf_section_offset (output_bfd
,
3864 if (offset
== (bfd_vma
) -1
3865 || offset
== (bfd_vma
) -2)
3868 outrel
.r_offset
= (input_section
->output_section
->vma
3869 + input_section
->output_offset
3872 if (h
->dynindx
== -1
3874 || bfd_link_executable (info
))
3876 /* This symbol is resolved locally. */
3877 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3878 bfd_put_32 (output_bfd
,
3879 (h
->root
.u
.def
.value
3880 + h
->root
.u
.def
.section
->output_section
->vma
3881 + h
->root
.u
.def
.section
->output_offset
),
3885 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3887 sreloc
= htab
->elf
.irelifunc
;
3888 elf_append_rel (output_bfd
, sreloc
, &outrel
);
3890 /* If this reloc is against an external symbol, we
3891 do not want to fiddle with the addend. Otherwise,
3892 we need to include the symbol value so that it
3893 becomes an addend for the dynamic reloc. For an
3894 internal symbol, we have updated addend. */
3904 base_got
= htab
->elf
.sgot
;
3905 off
= h
->got
.offset
;
3907 if (base_got
== NULL
)
3910 if (off
== (bfd_vma
) -1)
3912 /* We can't use h->got.offset here to save state, or
3913 even just remember the offset, as finish_dynamic_symbol
3914 would use that as offset into .got. */
3916 if (htab
->elf
.splt
!= NULL
)
3918 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3919 off
= (plt_index
+ 3) * 4;
3920 base_got
= htab
->elf
.sgotplt
;
3924 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3925 off
= plt_index
* 4;
3926 base_got
= htab
->elf
.igotplt
;
3929 if (h
->dynindx
== -1
3933 /* This references the local defitionion. We must
3934 initialize this entry in the global offset table.
3935 Since the offset must always be a multiple of 8,
3936 we use the least significant bit to record
3937 whether we have initialized it already.
3939 When doing a dynamic link, we create a .rela.got
3940 relocation entry to initialize the value. This
3941 is done in the finish_dynamic_symbol routine. */
3946 bfd_put_32 (output_bfd
, relocation
,
3947 base_got
->contents
+ off
);
3954 /* Adjust for static executables. */
3955 if (htab
->elf
.splt
== NULL
)
3956 relocation
+= gotplt
->output_offset
;
3960 relocation
= (base_got
->output_section
->vma
3961 + base_got
->output_offset
+ off
3962 - gotplt
->output_section
->vma
3963 - gotplt
->output_offset
);
3964 /* Adjust for static executables. */
3965 if (htab
->elf
.splt
== NULL
)
3966 relocation
+= gotplt
->output_offset
;
3972 relocation
-= (gotplt
->output_section
->vma
3973 + gotplt
->output_offset
);
3978 eh
= (struct elf_i386_link_hash_entry
*) h
;
3979 resolved_to_zero
= (eh
!= NULL
3980 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3987 /* Avoid optimizing _DYNAMIC since ld.so may use its
3988 link-time address. */
3989 if (h
== htab
->elf
.hdynamic
)
3992 if (bfd_link_pic (info
))
3994 /* It is OK to convert mov to lea and convert indirect
3995 branch to direct branch. It is OK to convert adc,
3996 add, and, cmp, or, sbb, sub, test, xor only when PIC
3998 unsigned int opcode
, addend
;
3999 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4002 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4003 if (opcode
!= 0x8b && opcode
!= 0xff)
4007 /* Resolve "mov GOT[(%reg)], %reg",
4008 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4009 and "binop foo@GOT[(%reg)], %reg". */
4011 || (h
->plt
.offset
== (bfd_vma
) -1
4012 && h
->got
.offset
== (bfd_vma
) -1)
4013 || htab
->elf
.sgotplt
== NULL
)
4016 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4017 + htab
->elf
.sgotplt
->output_offset
);
4019 /* It is relative to .got.plt section. */
4020 if (h
->got
.offset
!= (bfd_vma
) -1)
4021 /* Use GOT entry. Mask off the least significant bit in
4022 GOT offset which may be set by R_386_GOT32 processing
4024 relocation
= (htab
->elf
.sgot
->output_section
->vma
4025 + htab
->elf
.sgot
->output_offset
4026 + (h
->got
.offset
& ~1) - offplt
);
4028 /* Use GOTPLT entry. */
4029 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4031 if (!bfd_link_pic (info
))
4033 /* If not PIC, add the .got.plt section address for
4034 baseless addressing. */
4036 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4037 if ((modrm
& 0xc7) == 0x5)
4038 relocation
+= offplt
;
4041 unresolved_reloc
= FALSE
;
4046 /* Relocation is to the entry for this symbol in the global
4048 if (htab
->elf
.sgot
== NULL
)
4055 off
= h
->got
.offset
;
4056 dyn
= htab
->elf
.dynamic_sections_created
;
4057 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4058 bfd_link_pic (info
),
4060 || (bfd_link_pic (info
)
4061 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4062 || (ELF_ST_VISIBILITY (h
->other
)
4063 && h
->root
.type
== bfd_link_hash_undefweak
))
4065 /* This is actually a static link, or it is a
4066 -Bsymbolic link and the symbol is defined
4067 locally, or the symbol was forced to be local
4068 because of a version file. We must initialize
4069 this entry in the global offset table. Since the
4070 offset must always be a multiple of 4, we use the
4071 least significant bit to record whether we have
4072 initialized it already.
4074 When doing a dynamic link, we create a .rel.got
4075 relocation entry to initialize the value. This
4076 is done in the finish_dynamic_symbol routine. */
4081 bfd_put_32 (output_bfd
, relocation
,
4082 htab
->elf
.sgot
->contents
+ off
);
4087 unresolved_reloc
= FALSE
;
4091 if (local_got_offsets
== NULL
)
4094 off
= local_got_offsets
[r_symndx
];
4096 /* The offset must always be a multiple of 4. We use
4097 the least significant bit to record whether we have
4098 already generated the necessary reloc. */
4103 bfd_put_32 (output_bfd
, relocation
,
4104 htab
->elf
.sgot
->contents
+ off
);
4106 if (bfd_link_pic (info
))
4109 Elf_Internal_Rela outrel
;
4111 s
= htab
->elf
.srelgot
;
4115 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4116 + htab
->elf
.sgot
->output_offset
4118 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4119 elf_append_rel (output_bfd
, s
, &outrel
);
4122 local_got_offsets
[r_symndx
] |= 1;
4126 if (off
>= (bfd_vma
) -2)
4129 relocation
= htab
->elf
.sgot
->output_section
->vma
4130 + htab
->elf
.sgot
->output_offset
+ off
4131 - htab
->elf
.sgotplt
->output_section
->vma
4132 - htab
->elf
.sgotplt
->output_offset
;
4136 /* Relocation is relative to the start of the global offset
4139 /* Check to make sure it isn't a protected function or data
4140 symbol for shared library since it may not be local when
4141 used as function address or with copy relocation. We also
4142 need to make sure that a symbol is referenced locally. */
4143 if (!bfd_link_executable (info
) && h
)
4145 if (!h
->def_regular
)
4149 switch (ELF_ST_VISIBILITY (h
->other
))
4152 v
= _("hidden symbol");
4155 v
= _("internal symbol");
4158 v
= _("protected symbol");
4165 (*_bfd_error_handler
)
4166 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4167 input_bfd
, v
, h
->root
.root
.string
);
4168 bfd_set_error (bfd_error_bad_value
);
4171 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4172 && (h
->type
== STT_FUNC
4173 || h
->type
== STT_OBJECT
)
4174 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4176 (*_bfd_error_handler
)
4177 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4179 h
->type
== STT_FUNC
? "function" : "data",
4180 h
->root
.root
.string
);
4181 bfd_set_error (bfd_error_bad_value
);
4186 /* Note that sgot is not involved in this
4187 calculation. We always want the start of .got.plt. If we
4188 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4189 permitted by the ABI, we might have to change this
4191 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4192 + htab
->elf
.sgotplt
->output_offset
;
4196 /* Use global offset table as symbol value. */
4197 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4198 + htab
->elf
.sgotplt
->output_offset
;
4199 unresolved_reloc
= FALSE
;
4203 /* Relocation is to the entry for this symbol in the
4204 procedure linkage table. */
4206 /* Resolve a PLT32 reloc against a local symbol directly,
4207 without using the procedure linkage table. */
4211 if ((h
->plt
.offset
== (bfd_vma
) -1
4212 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4213 || htab
->elf
.splt
== NULL
)
4215 /* We didn't make a PLT entry for this symbol. This
4216 happens when statically linking PIC code, or when
4217 using -Bsymbolic. */
4221 if (h
->plt
.offset
!= (bfd_vma
) -1)
4223 resolved_plt
= htab
->elf
.splt
;
4224 plt_offset
= h
->plt
.offset
;
4228 resolved_plt
= htab
->plt_got
;
4229 plt_offset
= eh
->plt_got
.offset
;
4232 relocation
= (resolved_plt
->output_section
->vma
4233 + resolved_plt
->output_offset
4235 unresolved_reloc
= FALSE
;
4239 /* Set to symbol size. */
4240 relocation
= st_size
;
4245 if ((input_section
->flags
& SEC_ALLOC
) == 0
4249 /* Copy dynamic function pointer relocations. Don't generate
4250 dynamic relocations against resolved undefined weak symbols
4251 in PIE, except for R_386_PC32. */
4252 if ((bfd_link_pic (info
)
4254 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4255 && (!resolved_to_zero
4256 || r_type
== R_386_PC32
))
4257 || h
->root
.type
!= bfd_link_hash_undefweak
))
4258 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4259 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4260 || (ELIMINATE_COPY_RELOCS
4261 && !bfd_link_pic (info
)
4265 || eh
->func_pointer_refcount
> 0
4266 || (h
->root
.type
== bfd_link_hash_undefweak
4267 && !resolved_to_zero
))
4268 && ((h
->def_dynamic
&& !h
->def_regular
)
4269 /* Undefined weak symbol is bound locally when
4271 || h
->root
.type
== bfd_link_hash_undefweak
)))
4273 Elf_Internal_Rela outrel
;
4274 bfd_boolean skip
, relocate
;
4277 /* When generating a shared object, these relocations
4278 are copied into the output file to be resolved at run
4285 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4287 if (outrel
.r_offset
== (bfd_vma
) -1)
4289 else if (outrel
.r_offset
== (bfd_vma
) -2)
4290 skip
= TRUE
, relocate
= TRUE
;
4291 outrel
.r_offset
+= (input_section
->output_section
->vma
4292 + input_section
->output_offset
);
4295 memset (&outrel
, 0, sizeof outrel
);
4298 && (r_type
== R_386_PC32
4299 || !(bfd_link_executable (info
)
4300 || SYMBOLIC_BIND (info
, h
))
4301 || !h
->def_regular
))
4302 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4305 /* This symbol is local, or marked to become local. */
4307 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4310 sreloc
= elf_section_data (input_section
)->sreloc
;
4312 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4314 r
= bfd_reloc_notsupported
;
4315 goto check_relocation_error
;
4318 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4320 /* If this reloc is against an external symbol, we do
4321 not want to fiddle with the addend. Otherwise, we
4322 need to include the symbol value so that it becomes
4323 an addend for the dynamic reloc. */
4330 if (!bfd_link_executable (info
))
4332 Elf_Internal_Rela outrel
;
4335 outrel
.r_offset
= rel
->r_offset
4336 + input_section
->output_section
->vma
4337 + input_section
->output_offset
;
4338 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4339 sreloc
= elf_section_data (input_section
)->sreloc
;
4342 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4347 case R_386_TLS_GOTDESC
:
4348 case R_386_TLS_DESC_CALL
:
4349 case R_386_TLS_IE_32
:
4350 case R_386_TLS_GOTIE
:
4351 tls_type
= GOT_UNKNOWN
;
4352 if (h
== NULL
&& local_got_offsets
)
4353 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4355 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4356 if (tls_type
== GOT_TLS_IE
)
4357 tls_type
= GOT_TLS_IE_NEG
;
4359 if (! elf_i386_tls_transition (info
, input_bfd
,
4360 input_section
, contents
,
4361 symtab_hdr
, sym_hashes
,
4362 &r_type
, tls_type
, rel
,
4363 relend
, h
, r_symndx
, TRUE
))
4366 if (r_type
== R_386_TLS_LE_32
)
4368 BFD_ASSERT (! unresolved_reloc
);
4369 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4374 /* GD->LE transition. */
4375 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4378 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4380 movl %gs:0, %eax; subl $foo@tpoff, %eax
4381 (6 byte form of subl). */
4382 memcpy (contents
+ rel
->r_offset
- 3,
4383 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4384 roff
= rel
->r_offset
+ 5;
4388 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4390 movl %gs:0, %eax; subl $foo@tpoff, %eax
4391 (6 byte form of subl). */
4392 memcpy (contents
+ rel
->r_offset
- 2,
4393 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4394 roff
= rel
->r_offset
+ 6;
4396 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4398 /* Skip R_386_PC32/R_386_PLT32. */
4403 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4405 /* GDesc -> LE transition.
4406 It's originally something like:
4407 leal x@tlsdesc(%ebx), %eax
4411 Registers other than %eax may be set up here. */
4416 roff
= rel
->r_offset
;
4417 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4419 /* Now modify the instruction as appropriate. */
4420 /* aoliva FIXME: remove the above and xor the byte
4422 bfd_put_8 (output_bfd
, val
^ 0x86,
4423 contents
+ roff
- 1);
4424 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4428 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4430 /* GDesc -> LE transition.
4438 roff
= rel
->r_offset
;
4439 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4440 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4443 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4447 /* IE->LE transition:
4448 Originally it can be one of:
4456 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4459 /* movl foo, %eax. */
4460 bfd_put_8 (output_bfd
, 0xb8,
4461 contents
+ rel
->r_offset
- 1);
4467 type
= bfd_get_8 (input_bfd
,
4468 contents
+ rel
->r_offset
- 2);
4473 bfd_put_8 (output_bfd
, 0xc7,
4474 contents
+ rel
->r_offset
- 2);
4475 bfd_put_8 (output_bfd
,
4476 0xc0 | ((val
>> 3) & 7),
4477 contents
+ rel
->r_offset
- 1);
4481 bfd_put_8 (output_bfd
, 0x81,
4482 contents
+ rel
->r_offset
- 2);
4483 bfd_put_8 (output_bfd
,
4484 0xc0 | ((val
>> 3) & 7),
4485 contents
+ rel
->r_offset
- 1);
4492 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4493 contents
+ rel
->r_offset
);
4498 unsigned int val
, type
;
4500 /* {IE_32,GOTIE}->LE transition:
4501 Originally it can be one of:
4502 subl foo(%reg1), %reg2
4503 movl foo(%reg1), %reg2
4504 addl foo(%reg1), %reg2
4507 movl $foo, %reg2 (6 byte form)
4508 addl $foo, %reg2. */
4509 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4510 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4514 bfd_put_8 (output_bfd
, 0xc7,
4515 contents
+ rel
->r_offset
- 2);
4516 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4517 contents
+ rel
->r_offset
- 1);
4519 else if (type
== 0x2b)
4522 bfd_put_8 (output_bfd
, 0x81,
4523 contents
+ rel
->r_offset
- 2);
4524 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4525 contents
+ rel
->r_offset
- 1);
4527 else if (type
== 0x03)
4530 bfd_put_8 (output_bfd
, 0x81,
4531 contents
+ rel
->r_offset
- 2);
4532 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4533 contents
+ rel
->r_offset
- 1);
4537 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4538 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4539 contents
+ rel
->r_offset
);
4541 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4542 contents
+ rel
->r_offset
);
4547 if (htab
->elf
.sgot
== NULL
)
4552 off
= h
->got
.offset
;
4553 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4557 if (local_got_offsets
== NULL
)
4560 off
= local_got_offsets
[r_symndx
];
4561 offplt
= local_tlsdesc_gotents
[r_symndx
];
4568 Elf_Internal_Rela outrel
;
4572 if (htab
->elf
.srelgot
== NULL
)
4575 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4577 if (GOT_TLS_GDESC_P (tls_type
))
4580 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4581 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4582 <= htab
->elf
.sgotplt
->size
);
4583 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4584 + htab
->elf
.sgotplt
->output_offset
4586 + htab
->sgotplt_jump_table_size
);
4587 sreloc
= htab
->elf
.srelplt
;
4588 loc
= sreloc
->contents
;
4589 loc
+= (htab
->next_tls_desc_index
++
4590 * sizeof (Elf32_External_Rel
));
4591 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4592 <= sreloc
->contents
+ sreloc
->size
);
4593 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4596 BFD_ASSERT (! unresolved_reloc
);
4597 bfd_put_32 (output_bfd
,
4598 relocation
- elf_i386_dtpoff_base (info
),
4599 htab
->elf
.sgotplt
->contents
+ offplt
4600 + htab
->sgotplt_jump_table_size
+ 4);
4604 bfd_put_32 (output_bfd
, 0,
4605 htab
->elf
.sgotplt
->contents
+ offplt
4606 + htab
->sgotplt_jump_table_size
+ 4);
4610 sreloc
= htab
->elf
.srelgot
;
4612 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4613 + htab
->elf
.sgot
->output_offset
+ off
);
4615 if (GOT_TLS_GD_P (tls_type
))
4616 dr_type
= R_386_TLS_DTPMOD32
;
4617 else if (GOT_TLS_GDESC_P (tls_type
))
4619 else if (tls_type
== GOT_TLS_IE_POS
)
4620 dr_type
= R_386_TLS_TPOFF
;
4622 dr_type
= R_386_TLS_TPOFF32
;
4624 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4625 bfd_put_32 (output_bfd
,
4626 relocation
- elf_i386_dtpoff_base (info
),
4627 htab
->elf
.sgot
->contents
+ off
);
4628 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4629 bfd_put_32 (output_bfd
,
4630 elf_i386_dtpoff_base (info
) - relocation
,
4631 htab
->elf
.sgot
->contents
+ off
);
4632 else if (dr_type
!= R_386_TLS_DESC
)
4633 bfd_put_32 (output_bfd
, 0,
4634 htab
->elf
.sgot
->contents
+ off
);
4635 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4637 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4639 if (GOT_TLS_GD_P (tls_type
))
4643 BFD_ASSERT (! unresolved_reloc
);
4644 bfd_put_32 (output_bfd
,
4645 relocation
- elf_i386_dtpoff_base (info
),
4646 htab
->elf
.sgot
->contents
+ off
+ 4);
4650 bfd_put_32 (output_bfd
, 0,
4651 htab
->elf
.sgot
->contents
+ off
+ 4);
4652 outrel
.r_info
= ELF32_R_INFO (indx
,
4653 R_386_TLS_DTPOFF32
);
4654 outrel
.r_offset
+= 4;
4655 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4658 else if (tls_type
== GOT_TLS_IE_BOTH
)
4660 bfd_put_32 (output_bfd
,
4662 ? relocation
- elf_i386_dtpoff_base (info
)
4664 htab
->elf
.sgot
->contents
+ off
+ 4);
4665 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4666 outrel
.r_offset
+= 4;
4667 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4674 local_got_offsets
[r_symndx
] |= 1;
4677 if (off
>= (bfd_vma
) -2
4678 && ! GOT_TLS_GDESC_P (tls_type
))
4680 if (r_type
== R_386_TLS_GOTDESC
4681 || r_type
== R_386_TLS_DESC_CALL
)
4683 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4684 unresolved_reloc
= FALSE
;
4686 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4688 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4689 + htab
->elf
.sgotplt
->output_offset
;
4690 relocation
= htab
->elf
.sgot
->output_section
->vma
4691 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4692 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4693 && tls_type
== GOT_TLS_IE_BOTH
)
4695 if (r_type
== R_386_TLS_IE
)
4696 relocation
+= g_o_t
;
4697 unresolved_reloc
= FALSE
;
4699 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4701 unsigned int val
, type
;
4704 /* GD->IE transition. */
4705 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4706 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4709 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4711 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4713 roff
= rel
->r_offset
- 3;
4717 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4719 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4720 roff
= rel
->r_offset
- 2;
4722 memcpy (contents
+ roff
,
4723 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4724 contents
[roff
+ 7] = 0x80 | (val
& 7);
4725 /* If foo is used only with foo@gotntpoff(%reg) and
4726 foo@indntpoff, but not with foo@gottpoff(%reg), change
4727 subl $foo@gottpoff(%reg), %eax
4729 addl $foo@gotntpoff(%reg), %eax. */
4730 if (tls_type
== GOT_TLS_IE_POS
)
4731 contents
[roff
+ 6] = 0x03;
4732 bfd_put_32 (output_bfd
,
4733 htab
->elf
.sgot
->output_section
->vma
4734 + htab
->elf
.sgot
->output_offset
+ off
4735 - htab
->elf
.sgotplt
->output_section
->vma
4736 - htab
->elf
.sgotplt
->output_offset
,
4737 contents
+ roff
+ 8);
4738 /* Skip R_386_PLT32. */
4743 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4745 /* GDesc -> IE transition.
4746 It's originally something like:
4747 leal x@tlsdesc(%ebx), %eax
4750 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4752 movl x@gottpoff(%ebx), %eax # before negl %eax
4754 Registers other than %eax may be set up here. */
4758 /* First, make sure it's a leal adding ebx to a 32-bit
4759 offset into any register, although it's probably
4760 almost always going to be eax. */
4761 roff
= rel
->r_offset
;
4763 /* Now modify the instruction as appropriate. */
4764 /* To turn a leal into a movl in the form we use it, it
4765 suffices to change the first byte from 0x8d to 0x8b.
4766 aoliva FIXME: should we decide to keep the leal, all
4767 we have to do is remove the statement below, and
4768 adjust the relaxation of R_386_TLS_DESC_CALL. */
4769 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4771 if (tls_type
== GOT_TLS_IE_BOTH
)
4774 bfd_put_32 (output_bfd
,
4775 htab
->elf
.sgot
->output_section
->vma
4776 + htab
->elf
.sgot
->output_offset
+ off
4777 - htab
->elf
.sgotplt
->output_section
->vma
4778 - htab
->elf
.sgotplt
->output_offset
,
4782 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4784 /* GDesc -> IE transition.
4792 depending on how we transformed the TLS_GOTDESC above.
4797 roff
= rel
->r_offset
;
4799 /* Now modify the instruction as appropriate. */
4800 if (tls_type
!= GOT_TLS_IE_NEG
)
4803 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4804 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4809 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
4810 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
4820 if (! elf_i386_tls_transition (info
, input_bfd
,
4821 input_section
, contents
,
4822 symtab_hdr
, sym_hashes
,
4823 &r_type
, GOT_UNKNOWN
, rel
,
4824 relend
, h
, r_symndx
, TRUE
))
4827 if (r_type
!= R_386_TLS_LDM
)
4829 /* LD->LE transition:
4830 leal foo(%reg), %eax; call ___tls_get_addr.
4832 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4833 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
4834 memcpy (contents
+ rel
->r_offset
- 2,
4835 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4836 /* Skip R_386_PC32/R_386_PLT32. */
4842 if (htab
->elf
.sgot
== NULL
)
4845 off
= htab
->tls_ldm_got
.offset
;
4850 Elf_Internal_Rela outrel
;
4852 if (htab
->elf
.srelgot
== NULL
)
4855 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4856 + htab
->elf
.sgot
->output_offset
+ off
);
4858 bfd_put_32 (output_bfd
, 0,
4859 htab
->elf
.sgot
->contents
+ off
);
4860 bfd_put_32 (output_bfd
, 0,
4861 htab
->elf
.sgot
->contents
+ off
+ 4);
4862 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
4863 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
4864 htab
->tls_ldm_got
.offset
|= 1;
4866 relocation
= htab
->elf
.sgot
->output_section
->vma
4867 + htab
->elf
.sgot
->output_offset
+ off
4868 - htab
->elf
.sgotplt
->output_section
->vma
4869 - htab
->elf
.sgotplt
->output_offset
;
4870 unresolved_reloc
= FALSE
;
4873 case R_386_TLS_LDO_32
:
4874 if (!bfd_link_executable (info
)
4875 || (input_section
->flags
& SEC_CODE
) == 0)
4876 relocation
-= elf_i386_dtpoff_base (info
);
4878 /* When converting LDO to LE, we must negate. */
4879 relocation
= -elf_i386_tpoff (info
, relocation
);
4882 case R_386_TLS_LE_32
:
4884 if (!bfd_link_executable (info
))
4886 Elf_Internal_Rela outrel
;
4889 outrel
.r_offset
= rel
->r_offset
4890 + input_section
->output_section
->vma
4891 + input_section
->output_offset
;
4892 if (h
!= NULL
&& h
->dynindx
!= -1)
4896 if (r_type
== R_386_TLS_LE_32
)
4897 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
4899 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4900 sreloc
= elf_section_data (input_section
)->sreloc
;
4903 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4906 else if (r_type
== R_386_TLS_LE_32
)
4907 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
4909 relocation
-= elf_i386_dtpoff_base (info
);
4911 else if (r_type
== R_386_TLS_LE_32
)
4912 relocation
= elf_i386_tpoff (info
, relocation
);
4914 relocation
= -elf_i386_tpoff (info
, relocation
);
4921 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4922 because such sections are not SEC_ALLOC and thus ld.so will
4923 not process them. */
4924 if (unresolved_reloc
4925 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4927 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4928 rel
->r_offset
) != (bfd_vma
) -1)
4930 (*_bfd_error_handler
)
4931 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4934 (long) rel
->r_offset
,
4936 h
->root
.root
.string
);
4941 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4942 contents
, rel
->r_offset
,
4945 check_relocation_error
:
4946 if (r
!= bfd_reloc_ok
)
4951 name
= h
->root
.root
.string
;
4954 name
= bfd_elf_string_from_elf_section (input_bfd
,
4955 symtab_hdr
->sh_link
,
4960 name
= bfd_section_name (input_bfd
, sec
);
4963 if (r
== bfd_reloc_overflow
)
4964 (*info
->callbacks
->reloc_overflow
)
4965 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4966 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4969 (*_bfd_error_handler
)
4970 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4971 input_bfd
, input_section
,
4972 (long) rel
->r_offset
, name
, (int) r
);
4983 Elf_Internal_Shdr
*rel_hdr
;
4984 size_t deleted
= rel
- wrel
;
4986 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4987 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4988 if (rel_hdr
->sh_size
== 0)
4990 /* It is too late to remove an empty reloc section. Leave
4992 ??? What is wrong with an empty section??? */
4993 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4996 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
4997 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4998 input_section
->reloc_count
-= deleted
;
5004 /* Finish up dynamic symbol handling. We set the contents of various
5005 dynamic sections here. */
5008 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5009 struct bfd_link_info
*info
,
5010 struct elf_link_hash_entry
*h
,
5011 Elf_Internal_Sym
*sym
)
5013 struct elf_i386_link_hash_table
*htab
;
5014 unsigned plt_entry_size
;
5015 const struct elf_i386_backend_data
*abed
;
5016 struct elf_i386_link_hash_entry
*eh
;
5017 bfd_boolean local_undefweak
;
5019 htab
= elf_i386_hash_table (info
);
5023 abed
= get_elf_i386_backend_data (output_bfd
);
5024 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5026 eh
= (struct elf_i386_link_hash_entry
*) h
;
5028 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5029 resolved undefined weak symbols in executable so that their
5030 references have value 0 at run-time. */
5031 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5035 if (h
->plt
.offset
!= (bfd_vma
) -1)
5039 Elf_Internal_Rela rel
;
5041 asection
*plt
, *gotplt
, *relplt
;
5043 /* When building a static executable, use .iplt, .igot.plt and
5044 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5045 if (htab
->elf
.splt
!= NULL
)
5047 plt
= htab
->elf
.splt
;
5048 gotplt
= htab
->elf
.sgotplt
;
5049 relplt
= htab
->elf
.srelplt
;
5053 plt
= htab
->elf
.iplt
;
5054 gotplt
= htab
->elf
.igotplt
;
5055 relplt
= htab
->elf
.irelplt
;
5058 /* This symbol has an entry in the procedure linkage table. Set
5061 if ((h
->dynindx
== -1
5063 && !((h
->forced_local
|| bfd_link_executable (info
))
5065 && h
->type
== STT_GNU_IFUNC
))
5071 /* Get the index in the procedure linkage table which
5072 corresponds to this symbol. This is the index of this symbol
5073 in all the symbols for which we are making plt entries. The
5074 first entry in the procedure linkage table is reserved.
5076 Get the offset into the .got table of the entry that
5077 corresponds to this function. Each .got entry is 4 bytes.
5078 The first three are reserved.
5080 For static executables, we don't reserve anything. */
5082 if (plt
== htab
->elf
.splt
)
5084 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5085 got_offset
= (got_offset
+ 3) * 4;
5089 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5090 got_offset
= got_offset
* 4;
5093 /* Fill in the entry in the procedure linkage table. */
5094 if (! bfd_link_pic (info
))
5096 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5097 abed
->plt
->plt_entry_size
);
5098 bfd_put_32 (output_bfd
,
5099 (gotplt
->output_section
->vma
5100 + gotplt
->output_offset
5102 plt
->contents
+ h
->plt
.offset
5103 + abed
->plt
->plt_got_offset
);
5105 if (abed
->is_vxworks
)
5107 int s
, k
, reloc_index
;
5109 /* Create the R_386_32 relocation referencing the GOT
5110 for this PLT entry. */
5112 /* S: Current slot number (zero-based). */
5113 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5114 / abed
->plt
->plt_entry_size
);
5115 /* K: Number of relocations for PLTResolve. */
5116 if (bfd_link_pic (info
))
5117 k
= PLTRESOLVE_RELOCS_SHLIB
;
5119 k
= PLTRESOLVE_RELOCS
;
5120 /* Skip the PLTresolve relocations, and the relocations for
5121 the other PLT slots. */
5122 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5123 loc
= (htab
->srelplt2
->contents
+ reloc_index
5124 * sizeof (Elf32_External_Rel
));
5126 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5127 + htab
->elf
.splt
->output_offset
5128 + h
->plt
.offset
+ 2),
5129 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5130 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5132 /* Create the R_386_32 relocation referencing the beginning of
5133 the PLT for this GOT entry. */
5134 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5135 + htab
->elf
.sgotplt
->output_offset
5137 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5138 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5139 loc
+ sizeof (Elf32_External_Rel
));
5144 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5145 abed
->plt
->plt_entry_size
);
5146 bfd_put_32 (output_bfd
, got_offset
,
5147 plt
->contents
+ h
->plt
.offset
5148 + abed
->plt
->plt_got_offset
);
5151 /* Fill in the entry in the global offset table. Leave the entry
5152 as zero for undefined weak symbol in PIE. No PLT relocation
5153 against undefined weak symbol in PIE. */
5154 if (!local_undefweak
)
5156 bfd_put_32 (output_bfd
,
5157 (plt
->output_section
->vma
5158 + plt
->output_offset
5160 + abed
->plt
->plt_lazy_offset
),
5161 gotplt
->contents
+ got_offset
);
5163 /* Fill in the entry in the .rel.plt section. */
5164 rel
.r_offset
= (gotplt
->output_section
->vma
5165 + gotplt
->output_offset
5167 if (h
->dynindx
== -1
5168 || ((bfd_link_executable (info
)
5169 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5171 && h
->type
== STT_GNU_IFUNC
))
5173 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5174 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5175 in the .got.plt section. */
5176 bfd_put_32 (output_bfd
,
5177 (h
->root
.u
.def
.value
5178 + h
->root
.u
.def
.section
->output_section
->vma
5179 + h
->root
.u
.def
.section
->output_offset
),
5180 gotplt
->contents
+ got_offset
);
5181 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5182 /* R_386_IRELATIVE comes last. */
5183 plt_index
= htab
->next_irelative_index
--;
5187 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5188 plt_index
= htab
->next_jump_slot_index
++;
5191 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5192 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5194 /* Don't fill PLT entry for static executables. */
5195 if (plt
== htab
->elf
.splt
)
5197 bfd_put_32 (output_bfd
,
5198 plt_index
* sizeof (Elf32_External_Rel
),
5199 plt
->contents
+ h
->plt
.offset
5200 + abed
->plt
->plt_reloc_offset
);
5201 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5202 + abed
->plt
->plt_plt_offset
+ 4),
5203 plt
->contents
+ h
->plt
.offset
5204 + abed
->plt
->plt_plt_offset
);
5208 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5210 bfd_vma got_offset
, plt_offset
;
5211 asection
*plt
, *got
, *gotplt
;
5212 const bfd_byte
*got_plt_entry
;
5214 /* Offset of displacement of the indirect jump. */
5215 bfd_vma plt_got_offset
= 2;
5217 /* Set the entry in the GOT procedure linkage table. */
5218 plt
= htab
->plt_got
;
5219 got
= htab
->elf
.sgot
;
5220 gotplt
= htab
->elf
.sgotplt
;
5221 got_offset
= h
->got
.offset
;
5223 if (got_offset
== (bfd_vma
) -1
5229 /* Fill in the entry in the GOT procedure linkage table. */
5230 if (! bfd_link_pic (info
))
5232 got_plt_entry
= elf_i386_got_plt_entry
;
5233 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5237 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5238 got_offset
+= (got
->output_section
->vma
5239 + got
->output_offset
5240 - gotplt
->output_section
->vma
5241 - gotplt
->output_offset
);
5244 plt_offset
= eh
->plt_got
.offset
;
5245 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5246 sizeof (elf_i386_got_plt_entry
));
5247 bfd_put_32 (output_bfd
, got_offset
,
5248 plt
->contents
+ plt_offset
+ plt_got_offset
);
5251 if (!local_undefweak
5253 && (h
->plt
.offset
!= (bfd_vma
) -1
5254 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5256 /* Mark the symbol as undefined, rather than as defined in
5257 the .plt section. Leave the value if there were any
5258 relocations where pointer equality matters (this is a clue
5259 for the dynamic linker, to make function pointer
5260 comparisons work between an application and shared
5261 library), otherwise set it to zero. If a function is only
5262 called from a binary, there is no need to slow down
5263 shared libraries because of that. */
5264 sym
->st_shndx
= SHN_UNDEF
;
5265 if (!h
->pointer_equality_needed
)
5269 /* Don't generate dynamic GOT relocation against undefined weak
5270 symbol in executable. */
5271 if (h
->got
.offset
!= (bfd_vma
) -1
5272 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5273 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5274 && !local_undefweak
)
5276 Elf_Internal_Rela rel
;
5278 /* This symbol has an entry in the global offset table. Set it
5281 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5284 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5285 + htab
->elf
.sgot
->output_offset
5286 + (h
->got
.offset
& ~(bfd_vma
) 1));
5288 /* If this is a static link, or it is a -Bsymbolic link and the
5289 symbol is defined locally or was forced to be local because
5290 of a version file, we just want to emit a RELATIVE reloc.
5291 The entry in the global offset table will already have been
5292 initialized in the relocate_section function. */
5294 && h
->type
== STT_GNU_IFUNC
)
5296 if (bfd_link_pic (info
))
5298 /* Generate R_386_GLOB_DAT. */
5305 if (!h
->pointer_equality_needed
)
5308 /* For non-shared object, we can't use .got.plt, which
5309 contains the real function addres if we need pointer
5310 equality. We load the GOT entry with the PLT entry. */
5311 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5312 bfd_put_32 (output_bfd
,
5313 (plt
->output_section
->vma
5314 + plt
->output_offset
+ h
->plt
.offset
),
5315 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5319 else if (bfd_link_pic (info
)
5320 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5322 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5323 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5327 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5329 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5330 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5331 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5334 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &rel
);
5339 Elf_Internal_Rela rel
;
5341 /* This symbol needs a copy reloc. Set it up. */
5343 if (h
->dynindx
== -1
5344 || (h
->root
.type
!= bfd_link_hash_defined
5345 && h
->root
.type
!= bfd_link_hash_defweak
)
5346 || htab
->srelbss
== NULL
)
5349 rel
.r_offset
= (h
->root
.u
.def
.value
5350 + h
->root
.u
.def
.section
->output_section
->vma
5351 + h
->root
.u
.def
.section
->output_offset
);
5352 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5353 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5359 /* Finish up local dynamic symbol handling. We set the contents of
5360 various dynamic sections here. */
5363 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5365 struct elf_link_hash_entry
*h
5366 = (struct elf_link_hash_entry
*) *slot
;
5367 struct bfd_link_info
*info
5368 = (struct bfd_link_info
*) inf
;
5370 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5374 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5375 here since undefined weak symbol may not be dynamic and may not be
5376 called for elf_i386_finish_dynamic_symbol. */
5379 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5382 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5383 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5385 if (h
->root
.type
!= bfd_link_hash_undefweak
5386 || h
->dynindx
!= -1)
5389 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5393 /* Used to decide how to sort relocs in an optimal manner for the
5394 dynamic linker, before writing them out. */
5396 static enum elf_reloc_type_class
5397 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5398 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5399 const Elf_Internal_Rela
*rela
)
5401 bfd
*abfd
= info
->output_bfd
;
5402 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5403 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5405 if (htab
->dynsym
!= NULL
5406 && htab
->dynsym
->contents
!= NULL
)
5408 /* Check relocation against STT_GNU_IFUNC symbol if there are
5410 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5411 Elf_Internal_Sym sym
;
5412 if (!bed
->s
->swap_symbol_in (abfd
,
5413 (htab
->dynsym
->contents
5414 + r_symndx
* sizeof (Elf32_External_Sym
)),
5418 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5419 return reloc_class_ifunc
;
5422 switch (ELF32_R_TYPE (rela
->r_info
))
5424 case R_386_RELATIVE
:
5425 return reloc_class_relative
;
5426 case R_386_JUMP_SLOT
:
5427 return reloc_class_plt
;
5429 return reloc_class_copy
;
5431 return reloc_class_normal
;
5435 /* Finish up the dynamic sections. */
5438 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5439 struct bfd_link_info
*info
)
5441 struct elf_i386_link_hash_table
*htab
;
5444 const struct elf_i386_backend_data
*abed
;
5446 htab
= elf_i386_hash_table (info
);
5450 dynobj
= htab
->elf
.dynobj
;
5451 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5452 abed
= get_elf_i386_backend_data (output_bfd
);
5454 if (htab
->elf
.dynamic_sections_created
)
5456 Elf32_External_Dyn
*dyncon
, *dynconend
;
5458 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5461 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5462 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5463 for (; dyncon
< dynconend
; dyncon
++)
5465 Elf_Internal_Dyn dyn
;
5468 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5473 if (abed
->is_vxworks
5474 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5479 s
= htab
->elf
.sgotplt
;
5480 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5484 s
= htab
->elf
.srelplt
;
5485 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5489 s
= htab
->elf
.srelplt
;
5490 dyn
.d_un
.d_val
= s
->size
;
5494 /* My reading of the SVR4 ABI indicates that the
5495 procedure linkage table relocs (DT_JMPREL) should be
5496 included in the overall relocs (DT_REL). This is
5497 what Solaris does. However, UnixWare can not handle
5498 that case. Therefore, we override the DT_RELSZ entry
5499 here to make it not include the JMPREL relocs. */
5500 s
= htab
->elf
.srelplt
;
5503 dyn
.d_un
.d_val
-= s
->size
;
5507 /* We may not be using the standard ELF linker script.
5508 If .rel.plt is the first .rel section, we adjust
5509 DT_REL to not include it. */
5510 s
= htab
->elf
.srelplt
;
5513 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5515 dyn
.d_un
.d_ptr
+= s
->size
;
5519 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5522 /* Fill in the first entry in the procedure linkage table. */
5523 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5525 if (bfd_link_pic (info
))
5527 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5528 abed
->plt
->plt0_entry_size
);
5529 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5530 abed
->plt0_pad_byte
,
5531 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5535 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5536 abed
->plt
->plt0_entry_size
);
5537 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5538 abed
->plt0_pad_byte
,
5539 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5540 bfd_put_32 (output_bfd
,
5541 (htab
->elf
.sgotplt
->output_section
->vma
5542 + htab
->elf
.sgotplt
->output_offset
5544 htab
->elf
.splt
->contents
5545 + abed
->plt
->plt0_got1_offset
);
5546 bfd_put_32 (output_bfd
,
5547 (htab
->elf
.sgotplt
->output_section
->vma
5548 + htab
->elf
.sgotplt
->output_offset
5550 htab
->elf
.splt
->contents
5551 + abed
->plt
->plt0_got2_offset
);
5553 if (abed
->is_vxworks
)
5555 Elf_Internal_Rela rel
;
5557 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5558 On IA32 we use REL relocations so the addend goes in
5559 the PLT directly. */
5560 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5561 + htab
->elf
.splt
->output_offset
5562 + abed
->plt
->plt0_got1_offset
);
5563 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5564 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5565 htab
->srelplt2
->contents
);
5566 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5567 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5568 + htab
->elf
.splt
->output_offset
5569 + abed
->plt
->plt0_got2_offset
);
5570 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5571 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5572 htab
->srelplt2
->contents
+
5573 sizeof (Elf32_External_Rel
));
5577 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5578 really seem like the right value. */
5579 elf_section_data (htab
->elf
.splt
->output_section
)
5580 ->this_hdr
.sh_entsize
= 4;
5582 /* Correct the .rel.plt.unloaded relocations. */
5583 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5585 int num_plts
= (htab
->elf
.splt
->size
5586 / abed
->plt
->plt_entry_size
) - 1;
5589 p
= htab
->srelplt2
->contents
;
5590 if (bfd_link_pic (info
))
5591 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5593 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5595 for (; num_plts
; num_plts
--)
5597 Elf_Internal_Rela rel
;
5598 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5599 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5600 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5601 p
+= sizeof (Elf32_External_Rel
);
5603 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5604 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5605 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5606 p
+= sizeof (Elf32_External_Rel
);
5612 if (htab
->elf
.sgotplt
)
5614 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5616 (*_bfd_error_handler
)
5617 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5621 /* Fill in the first three entries in the global offset table. */
5622 if (htab
->elf
.sgotplt
->size
> 0)
5624 bfd_put_32 (output_bfd
,
5626 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5627 htab
->elf
.sgotplt
->contents
);
5628 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5629 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5632 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5635 /* Adjust .eh_frame for .plt section. */
5636 if (htab
->plt_eh_frame
!= NULL
5637 && htab
->plt_eh_frame
->contents
!= NULL
)
5639 if (htab
->elf
.splt
!= NULL
5640 && htab
->elf
.splt
->size
!= 0
5641 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5642 && htab
->elf
.splt
->output_section
!= NULL
5643 && htab
->plt_eh_frame
->output_section
!= NULL
)
5645 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5646 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5647 + htab
->plt_eh_frame
->output_offset
5648 + PLT_FDE_START_OFFSET
;
5649 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5650 htab
->plt_eh_frame
->contents
5651 + PLT_FDE_START_OFFSET
);
5653 if (htab
->plt_eh_frame
->sec_info_type
5654 == SEC_INFO_TYPE_EH_FRAME
)
5656 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5658 htab
->plt_eh_frame
->contents
))
5663 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5664 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5666 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5667 htab_traverse (htab
->loc_hash_table
,
5668 elf_i386_finish_local_dynamic_symbol
,
5671 /* Fill PLT entries for undefined weak symbols in PIE. */
5672 if (bfd_link_pie (info
))
5673 bfd_hash_traverse (&info
->hash
->table
,
5674 elf_i386_pie_finish_undefweak_symbol
,
5680 /* Return an array of PLT entry symbol values. */
5683 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5686 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5689 bfd_vma
*plt_sym_val
;
5691 bfd_byte
*plt_contents
;
5692 const struct elf_i386_backend_data
*bed
5693 = get_elf_i386_backend_data (abfd
);
5694 Elf_Internal_Shdr
*hdr
;
5696 /* Get the .plt section contents. */
5697 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5698 if (plt_contents
== NULL
)
5700 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5701 plt_contents
, 0, plt
->size
))
5704 free (plt_contents
);
5708 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5709 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5712 hdr
= &elf_section_data (relplt
)->this_hdr
;
5713 count
= relplt
->size
/ hdr
->sh_entsize
;
5715 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5716 if (plt_sym_val
== NULL
)
5719 for (i
= 0; i
< count
; i
++)
5720 plt_sym_val
[i
] = -1;
5722 plt_offset
= bed
->plt
->plt_entry_size
;
5723 p
= relplt
->relocation
;
5724 for (i
= 0; i
< count
; i
++, p
++)
5728 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5729 if (p
->howto
== NULL
)
5732 if (p
->howto
->type
!= R_386_JUMP_SLOT
5733 && p
->howto
->type
!= R_386_IRELATIVE
)
5736 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5737 + bed
->plt
->plt_reloc_offset
));
5738 reloc_index
/= sizeof (Elf32_External_Rel
);
5739 if (reloc_index
< count
)
5740 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5742 plt_offset
+= bed
->plt
->plt_entry_size
;
5744 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5746 if (plt_offset
>= plt
->size
)
5750 free (plt_contents
);
5755 /* Similar to _bfd_elf_get_synthetic_symtab. */
5758 elf_i386_get_synthetic_symtab (bfd
*abfd
,
5765 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
5766 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5767 dynsymcount
, dynsyms
, ret
,
5769 elf_i386_get_plt_sym_val
);
5772 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5775 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
5777 if (h
->plt
.offset
!= (bfd_vma
) -1
5779 && !h
->pointer_equality_needed
)
5782 return _bfd_elf_hash_symbol (h
);
5785 #define TARGET_LITTLE_SYM i386_elf32_vec
5786 #define TARGET_LITTLE_NAME "elf32-i386"
5787 #define ELF_ARCH bfd_arch_i386
5788 #define ELF_TARGET_ID I386_ELF_DATA
5789 #define ELF_MACHINE_CODE EM_386
5790 #define ELF_MAXPAGESIZE 0x1000
5792 #define elf_backend_can_gc_sections 1
5793 #define elf_backend_can_refcount 1
5794 #define elf_backend_want_got_plt 1
5795 #define elf_backend_plt_readonly 1
5796 #define elf_backend_want_plt_sym 0
5797 #define elf_backend_got_header_size 12
5798 #define elf_backend_plt_alignment 4
5799 #define elf_backend_extern_protected_data 1
5800 #define elf_backend_caches_rawsize 1
5802 /* Support RELA for objdump of prelink objects. */
5803 #define elf_info_to_howto elf_i386_info_to_howto_rel
5804 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5806 #define bfd_elf32_mkobject elf_i386_mkobject
5808 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5809 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5810 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5811 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5812 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5814 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5815 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5816 #define elf_backend_check_relocs elf_i386_check_relocs
5817 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5818 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5819 #define elf_backend_fake_sections elf_i386_fake_sections
5820 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5821 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5822 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5823 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5824 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5825 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5826 #define elf_backend_relocate_section elf_i386_relocate_section
5827 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5828 #define elf_backend_always_size_sections elf_i386_always_size_sections
5829 #define elf_backend_omit_section_dynsym \
5830 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5831 #define elf_backend_hash_symbol elf_i386_hash_symbol
5832 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5834 #include "elf32-target.h"
5836 /* FreeBSD support. */
5838 #undef TARGET_LITTLE_SYM
5839 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5840 #undef TARGET_LITTLE_NAME
5841 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5843 #define ELF_OSABI ELFOSABI_FREEBSD
5845 /* The kernel recognizes executables as valid only if they carry a
5846 "FreeBSD" label in the ELF header. So we put this label on all
5847 executables and (for simplicity) also all other object files. */
5850 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
5852 _bfd_elf_post_process_headers (abfd
, info
);
5854 #ifdef OLD_FREEBSD_ABI_LABEL
5856 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5857 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5858 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5863 #undef elf_backend_post_process_headers
5864 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5866 #define elf32_bed elf32_i386_fbsd_bed
5868 #undef elf_backend_add_symbol_hook
5870 #include "elf32-target.h"
5874 #undef TARGET_LITTLE_SYM
5875 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5876 #undef TARGET_LITTLE_NAME
5877 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5879 #undef elf_backend_post_process_headers
5881 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5882 objects won't be recognized. */
5886 #define elf32_bed elf32_i386_sol2_bed
5888 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5890 #undef elf_backend_static_tls_alignment
5891 #define elf_backend_static_tls_alignment 8
5893 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5895 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5897 #undef elf_backend_want_plt_sym
5898 #define elf_backend_want_plt_sym 1
5900 #undef elf_backend_strtab_flags
5901 #define elf_backend_strtab_flags SHF_STRINGS
5903 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5904 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5905 FALSE otherwise. ISECTION is the best guess matching section from the
5906 input bfd IBFD, but it might be NULL. */
5909 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
5910 bfd
*obfd ATTRIBUTE_UNUSED
,
5911 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
5912 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
5914 /* PR 19938: FIXME: Need to add code for setting the sh_info
5915 and sh_link fields of Solaris specific section types. */
5918 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5919 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5921 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5923 The following values should be set:
5926 -----------------------------------------------------------------------------
5927 SHT_SUNW_ancillary The section header index of 0
5928 [0x6fffffee] the associated string table.
5930 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5931 [0x6ffffff0] the associated symbol table. section header index of
5933 SHT_SUNW_capchain table,
5936 SHT_SUNW_symsort The section header index of 0
5937 [0x6ffffff1] the associated symbol table.
5939 SHT_SUNW_tlssort The section header index of 0
5940 [0x6ffffff2] the associated symbol table.
5942 SHT_SUNW_LDYNSYM The section header index of One greater than the
5943 [0x6ffffff3] the associated string table. symbol table index of the
5944 This index is the same string last local symbol,
5945 table used by the SHT_DYNSYM STB_LOCAL. Since
5946 section. SHT_SUNW_LDYNSYM only
5947 contains local symbols,
5948 sh_info is equivalent to
5949 the number of symbols in
5952 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5953 [0x6ffffff5] the section header index of to named strings, the
5954 the associated section header index of
5955 SHT_SUNW_capinfo table, the associated string
5956 otherwise 0. table, otherwise 0.
5958 SHT_SUNW_move The section header index of 0
5959 [0x6ffffffa] the associated symbol table.
5964 SHT_SUNW_syminfo The section header index of The section header index
5965 [0x6ffffffc] the associated symbol table. of the associated
5968 SHT_SUNW_verdef The section header index of The number of version
5969 [0x6ffffffd] the associated string table. definitions within the
5972 SHT_SUNW_verneed The section header index of The number of version
5973 [0x6ffffffe] the associated string table. dependencies within the
5976 SHT_SUNW_versym The section header index of 0
5977 [0x6fffffff] the associated symbol table. */
5980 #undef elf_backend_copy_special_section_fields
5981 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
5983 #include "elf32-target.h"
5985 /* Intel MCU support. */
5988 elf32_iamcu_elf_object_p (bfd
*abfd
)
5990 /* Set the right machine number for an IAMCU elf32 file. */
5991 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
5995 #undef TARGET_LITTLE_SYM
5996 #define TARGET_LITTLE_SYM iamcu_elf32_vec
5997 #undef TARGET_LITTLE_NAME
5998 #define TARGET_LITTLE_NAME "elf32-iamcu"
6000 #define ELF_ARCH bfd_arch_iamcu
6002 #undef ELF_MACHINE_CODE
6003 #define ELF_MACHINE_CODE EM_IAMCU
6008 #define elf32_bed elf32_iamcu_bed
6010 #undef elf_backend_object_p
6011 #define elf_backend_object_p elf32_iamcu_elf_object_p
6013 #undef elf_backend_static_tls_alignment
6015 #undef elf_backend_want_plt_sym
6016 #define elf_backend_want_plt_sym 0
6018 #undef elf_backend_strtab_flags
6019 #undef elf_backend_copy_special_section_fields
6021 #include "elf32-target.h"
6023 /* Restore defaults. */
6025 #define ELF_ARCH bfd_arch_i386
6026 #undef ELF_MACHINE_CODE
6027 #define ELF_MACHINE_CODE EM_386
6029 /* Native Client support. */
6031 #undef TARGET_LITTLE_SYM
6032 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6033 #undef TARGET_LITTLE_NAME
6034 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6036 #define elf32_bed elf32_i386_nacl_bed
6038 #undef ELF_MAXPAGESIZE
6039 #define ELF_MAXPAGESIZE 0x10000
6041 /* Restore defaults. */
6043 #undef elf_backend_want_plt_sym
6044 #define elf_backend_want_plt_sym 0
6045 #undef elf_backend_post_process_headers
6046 #undef elf_backend_static_tls_alignment
6048 /* NaCl uses substantially different PLT entries for the same effects. */
6050 #undef elf_backend_plt_alignment
6051 #define elf_backend_plt_alignment 5
6052 #define NACL_PLT_ENTRY_SIZE 64
6053 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6055 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6057 0xff, 0x35, /* pushl contents of address */
6058 0, 0, 0, 0, /* replaced with address of .got + 4. */
6059 0x8b, 0x0d, /* movl contents of address, %ecx */
6060 0, 0, 0, 0, /* replaced with address of .got + 8. */
6061 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6062 0xff, 0xe1 /* jmp *%ecx */
6065 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6067 0x8b, 0x0d, /* movl contents of address, %ecx */
6068 0, 0, 0, 0, /* replaced with GOT slot address. */
6069 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6070 0xff, 0xe1, /* jmp *%ecx */
6072 /* Pad to the next 32-byte boundary with nop instructions. */
6074 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6075 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6077 /* Lazy GOT entries point here (32-byte aligned). */
6078 0x68, /* pushl immediate */
6079 0, 0, 0, 0, /* replaced with reloc offset. */
6080 0xe9, /* jmp relative */
6081 0, 0, 0, 0, /* replaced with offset to .plt. */
6083 /* Pad to the next 32-byte boundary with nop instructions. */
6084 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6085 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6089 static const bfd_byte
6090 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6092 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6093 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6094 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6095 0xff, 0xe1, /* jmp *%ecx */
6097 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6098 so pad to that size with nop instructions. */
6099 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6102 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6104 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6105 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6106 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6107 0xff, 0xe1, /* jmp *%ecx */
6109 /* Pad to the next 32-byte boundary with nop instructions. */
6111 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6112 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6114 /* Lazy GOT entries point here (32-byte aligned). */
6115 0x68, /* pushl immediate */
6116 0, 0, 0, 0, /* replaced with offset into relocation table. */
6117 0xe9, /* jmp relative */
6118 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6120 /* Pad to the next 32-byte boundary with nop instructions. */
6121 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6122 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6126 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6128 #if (PLT_CIE_LENGTH != 20 \
6129 || PLT_FDE_LENGTH != 36 \
6130 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6131 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6132 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6134 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6135 0, 0, 0, 0, /* CIE ID */
6136 1, /* CIE version */
6137 'z', 'R', 0, /* Augmentation string */
6138 1, /* Code alignment factor */
6139 0x7c, /* Data alignment factor: -4 */
6140 8, /* Return address column */
6141 1, /* Augmentation size */
6142 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6143 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6144 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6145 DW_CFA_nop
, DW_CFA_nop
,
6147 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6148 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6149 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6150 0, 0, 0, 0, /* .plt size goes here */
6151 0, /* Augmentation size */
6152 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6153 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6154 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6155 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6156 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6157 13, /* Block length */
6158 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6159 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6160 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6161 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6162 DW_CFA_nop
, DW_CFA_nop
6165 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6167 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6168 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6169 2, /* plt0_got1_offset */
6170 8, /* plt0_got2_offset */
6171 elf_i386_nacl_plt_entry
, /* plt_entry */
6172 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6173 2, /* plt_got_offset */
6174 33, /* plt_reloc_offset */
6175 38, /* plt_plt_offset */
6176 32, /* plt_lazy_offset */
6177 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6178 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6179 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6180 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6183 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6185 &elf_i386_nacl_plt
, /* plt */
6186 0x90, /* plt0_pad_byte: nop insn */
6191 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6193 /* Set the right machine number for a NaCl i386 ELF32 file. */
6194 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6198 #undef elf_backend_arch_data
6199 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6201 #undef elf_backend_object_p
6202 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6203 #undef elf_backend_modify_segment_map
6204 #define elf_backend_modify_segment_map nacl_modify_segment_map
6205 #undef elf_backend_modify_program_headers
6206 #define elf_backend_modify_program_headers nacl_modify_program_headers
6207 #undef elf_backend_final_write_processing
6208 #define elf_backend_final_write_processing nacl_final_write_processing
6210 #include "elf32-target.h"
6212 /* Restore defaults. */
6213 #undef elf_backend_object_p
6214 #undef elf_backend_modify_segment_map
6215 #undef elf_backend_modify_program_headers
6216 #undef elf_backend_final_write_processing
6218 /* VxWorks support. */
6220 #undef TARGET_LITTLE_SYM
6221 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6222 #undef TARGET_LITTLE_NAME
6223 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6225 #undef elf_backend_plt_alignment
6226 #define elf_backend_plt_alignment 4
6228 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6230 &elf_i386_plt
, /* plt */
6231 0x90, /* plt0_pad_byte */
6235 #undef elf_backend_arch_data
6236 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6238 #undef elf_backend_relocs_compatible
6239 #undef elf_backend_add_symbol_hook
6240 #define elf_backend_add_symbol_hook \
6241 elf_vxworks_add_symbol_hook
6242 #undef elf_backend_link_output_symbol_hook
6243 #define elf_backend_link_output_symbol_hook \
6244 elf_vxworks_link_output_symbol_hook
6245 #undef elf_backend_emit_relocs
6246 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6247 #undef elf_backend_final_write_processing
6248 #define elf_backend_final_write_processing \
6249 elf_vxworks_final_write_processing
6250 #undef elf_backend_static_tls_alignment
6252 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6254 #undef elf_backend_want_plt_sym
6255 #define elf_backend_want_plt_sym 1
6258 #define elf32_bed elf32_i386_vxworks_bed
6260 #include "elf32-target.h"