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, EH) \
747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
750 || !(EH)->has_got_reloc \
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 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1073 if (bfd_link_executable (info
))
1075 /* Always allow copy relocs for building executables. */
1076 asection
*s
= bfd_get_linker_section (dynobj
, ".rel.bss");
1079 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1080 s
= bfd_make_section_anyway_with_flags (dynobj
,
1082 (bed
->dynamic_sec_flags
1085 || ! bfd_set_section_alignment (dynobj
, s
,
1086 bed
->s
->log_file_align
))
1092 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1093 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1097 if (!info
->no_ld_generated_unwind_info
1098 && htab
->plt_eh_frame
== NULL
1099 && htab
->elf
.splt
!= NULL
)
1101 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1102 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1103 | SEC_LINKER_CREATED
);
1105 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1106 if (htab
->plt_eh_frame
== NULL
1107 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1114 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1117 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1118 struct elf_link_hash_entry
*dir
,
1119 struct elf_link_hash_entry
*ind
)
1121 struct elf_i386_link_hash_entry
*edir
, *eind
;
1123 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1124 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1126 if (eind
->dyn_relocs
!= NULL
)
1128 if (edir
->dyn_relocs
!= NULL
)
1130 struct elf_dyn_relocs
**pp
;
1131 struct elf_dyn_relocs
*p
;
1133 /* Add reloc counts against the indirect sym to the direct sym
1134 list. Merge any entries against the same section. */
1135 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1137 struct elf_dyn_relocs
*q
;
1139 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1140 if (q
->sec
== p
->sec
)
1142 q
->pc_count
+= p
->pc_count
;
1143 q
->count
+= p
->count
;
1150 *pp
= edir
->dyn_relocs
;
1153 edir
->dyn_relocs
= eind
->dyn_relocs
;
1154 eind
->dyn_relocs
= NULL
;
1157 if (ind
->root
.type
== bfd_link_hash_indirect
1158 && dir
->got
.refcount
<= 0)
1160 edir
->tls_type
= eind
->tls_type
;
1161 eind
->tls_type
= GOT_UNKNOWN
;
1164 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1165 generate a R_386_COPY reloc. */
1166 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1168 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1169 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1171 if (ELIMINATE_COPY_RELOCS
1172 && ind
->root
.type
!= bfd_link_hash_indirect
1173 && dir
->dynamic_adjusted
)
1175 /* If called to transfer flags for a weakdef during processing
1176 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1177 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1178 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1179 dir
->ref_regular
|= ind
->ref_regular
;
1180 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1181 dir
->needs_plt
|= ind
->needs_plt
;
1182 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1186 if (eind
->func_pointer_refcount
> 0)
1188 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1189 eind
->func_pointer_refcount
= 0;
1192 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1196 /* Return TRUE if the TLS access code sequence support transition
1200 elf_i386_check_tls_transition (bfd
*abfd
, asection
*sec
,
1202 Elf_Internal_Shdr
*symtab_hdr
,
1203 struct elf_link_hash_entry
**sym_hashes
,
1204 unsigned int r_type
,
1205 const Elf_Internal_Rela
*rel
,
1206 const Elf_Internal_Rela
*relend
)
1208 unsigned int val
, type
;
1209 unsigned long r_symndx
;
1210 struct elf_link_hash_entry
*h
;
1213 /* Get the section contents. */
1214 if (contents
== NULL
)
1216 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1217 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1220 /* FIXME: How to better handle error condition? */
1221 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1224 /* Cache the section contents for elf_link_input_bfd. */
1225 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1229 offset
= rel
->r_offset
;
1234 if (offset
< 2 || (rel
+ 1) >= relend
)
1237 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1238 if (r_type
== R_386_TLS_GD
)
1240 /* Check transition from GD access model. Only
1241 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1242 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1243 can transit to different access model. */
1244 if ((offset
+ 10) > sec
->size
||
1245 (type
!= 0x8d && type
!= 0x04))
1248 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1251 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1255 if (bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x8d)
1258 if ((val
& 0xc7) != 0x05 || val
== (4 << 3))
1263 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1264 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1267 if (bfd_get_8 (abfd
, contents
+ offset
+ 9) != 0x90)
1273 /* Check transition from LD access model. Only
1274 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1275 can transit to different access model. */
1276 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1279 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1280 if ((val
& 0xf8) != 0x80 || (val
& 7) == 4)
1284 if (bfd_get_8 (abfd
, contents
+ offset
+ 4) != 0xe8)
1287 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1288 if (r_symndx
< symtab_hdr
->sh_info
)
1291 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1292 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1293 may be versioned. */
1295 && h
->root
.root
.string
!= NULL
1296 && (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1297 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
)
1298 && (strncmp (h
->root
.root
.string
, "___tls_get_addr",
1302 /* Check transition from IE access model:
1303 movl foo@indntpoff(%rip), %eax
1304 movl foo@indntpoff(%rip), %reg
1305 addl foo@indntpoff(%rip), %reg
1308 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1311 /* Check "movl foo@tpoff(%rip), %eax" first. */
1312 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1319 /* Check movl|addl foo@tpoff(%rip), %reg. */
1320 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1321 return ((type
== 0x8b || type
== 0x03)
1322 && (val
& 0xc7) == 0x05);
1324 case R_386_TLS_GOTIE
:
1325 case R_386_TLS_IE_32
:
1326 /* Check transition from {IE_32,GOTIE} access model:
1327 subl foo@{tpoff,gontoff}(%reg1), %reg2
1328 movl foo@{tpoff,gontoff}(%reg1), %reg2
1329 addl foo@{tpoff,gontoff}(%reg1), %reg2
1332 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1335 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1336 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1339 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1340 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1342 case R_386_TLS_GOTDESC
:
1343 /* Check transition from GDesc access model:
1344 leal x@tlsdesc(%ebx), %eax
1346 Make sure it's a leal adding ebx to a 32-bit offset
1347 into any register, although it's probably almost always
1350 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1353 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1356 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1357 return (val
& 0xc7) == 0x83;
1359 case R_386_TLS_DESC_CALL
:
1360 /* Check transition from GDesc access model:
1361 call *x@tlsdesc(%rax)
1363 if (offset
+ 2 <= sec
->size
)
1365 /* Make sure that it's a call *x@tlsdesc(%rax). */
1366 static const unsigned char call
[] = { 0xff, 0x10 };
1367 return memcmp (contents
+ offset
, call
, 2) == 0;
1377 /* Return TRUE if the TLS access transition is OK or no transition
1378 will be performed. Update R_TYPE if there is a transition. */
1381 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1382 asection
*sec
, bfd_byte
*contents
,
1383 Elf_Internal_Shdr
*symtab_hdr
,
1384 struct elf_link_hash_entry
**sym_hashes
,
1385 unsigned int *r_type
, int tls_type
,
1386 const Elf_Internal_Rela
*rel
,
1387 const Elf_Internal_Rela
*relend
,
1388 struct elf_link_hash_entry
*h
,
1389 unsigned long r_symndx
)
1391 unsigned int from_type
= *r_type
;
1392 unsigned int to_type
= from_type
;
1393 bfd_boolean check
= TRUE
;
1395 /* Skip TLS transition for functions. */
1397 && (h
->type
== STT_FUNC
1398 || h
->type
== STT_GNU_IFUNC
))
1404 case R_386_TLS_GOTDESC
:
1405 case R_386_TLS_DESC_CALL
:
1406 case R_386_TLS_IE_32
:
1408 case R_386_TLS_GOTIE
:
1409 if (bfd_link_executable (info
))
1412 to_type
= R_386_TLS_LE_32
;
1413 else if (from_type
!= R_386_TLS_IE
1414 && from_type
!= R_386_TLS_GOTIE
)
1415 to_type
= R_386_TLS_IE_32
;
1418 /* When we are called from elf_i386_relocate_section, CONTENTS
1419 isn't NULL and there may be additional transitions based on
1421 if (contents
!= NULL
)
1423 unsigned int new_to_type
= to_type
;
1425 if (bfd_link_executable (info
)
1428 && (tls_type
& GOT_TLS_IE
))
1429 new_to_type
= R_386_TLS_LE_32
;
1431 if (to_type
== R_386_TLS_GD
1432 || to_type
== R_386_TLS_GOTDESC
1433 || to_type
== R_386_TLS_DESC_CALL
)
1435 if (tls_type
== GOT_TLS_IE_POS
)
1436 new_to_type
= R_386_TLS_GOTIE
;
1437 else if (tls_type
& GOT_TLS_IE
)
1438 new_to_type
= R_386_TLS_IE_32
;
1441 /* We checked the transition before when we were called from
1442 elf_i386_check_relocs. We only want to check the new
1443 transition which hasn't been checked before. */
1444 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1445 to_type
= new_to_type
;
1451 if (bfd_link_executable (info
))
1452 to_type
= R_386_TLS_LE_32
;
1459 /* Return TRUE if there is no transition. */
1460 if (from_type
== to_type
)
1463 /* Check if the transition can be performed. */
1465 && ! elf_i386_check_tls_transition (abfd
, sec
, contents
,
1466 symtab_hdr
, sym_hashes
,
1467 from_type
, rel
, relend
))
1469 reloc_howto_type
*from
, *to
;
1472 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1473 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1476 name
= h
->root
.root
.string
;
1479 struct elf_i386_link_hash_table
*htab
;
1481 htab
= elf_i386_hash_table (info
);
1486 Elf_Internal_Sym
*isym
;
1488 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1490 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1494 (*_bfd_error_handler
)
1495 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1496 "in section `%A' failed"),
1497 abfd
, sec
, from
->name
, to
->name
, name
,
1498 (unsigned long) rel
->r_offset
);
1499 bfd_set_error (bfd_error_bad_value
);
1507 /* Rename some of the generic section flags to better document how they
1509 #define need_convert_load sec_flg0
1511 /* Look through the relocs for a section during the first phase, and
1512 calculate needed space in the global offset table, procedure linkage
1513 table, and dynamic reloc sections. */
1516 elf_i386_check_relocs (bfd
*abfd
,
1517 struct bfd_link_info
*info
,
1519 const Elf_Internal_Rela
*relocs
)
1521 struct elf_i386_link_hash_table
*htab
;
1522 Elf_Internal_Shdr
*symtab_hdr
;
1523 struct elf_link_hash_entry
**sym_hashes
;
1524 const Elf_Internal_Rela
*rel
;
1525 const Elf_Internal_Rela
*rel_end
;
1527 bfd_boolean use_plt_got
;
1529 if (bfd_link_relocatable (info
))
1532 BFD_ASSERT (is_i386_elf (abfd
));
1534 htab
= elf_i386_hash_table (info
);
1538 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1539 && (get_elf_i386_backend_data (abfd
)
1540 == &elf_i386_arch_bed
));
1542 symtab_hdr
= &elf_symtab_hdr (abfd
);
1543 sym_hashes
= elf_sym_hashes (abfd
);
1547 rel_end
= relocs
+ sec
->reloc_count
;
1548 for (rel
= relocs
; rel
< rel_end
; rel
++)
1550 unsigned int r_type
;
1551 unsigned long r_symndx
;
1552 struct elf_link_hash_entry
*h
;
1553 struct elf_i386_link_hash_entry
*eh
;
1554 Elf_Internal_Sym
*isym
;
1556 bfd_boolean size_reloc
;
1558 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1559 r_type
= ELF32_R_TYPE (rel
->r_info
);
1561 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1563 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1569 if (r_symndx
< symtab_hdr
->sh_info
)
1571 /* A local symbol. */
1572 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1577 /* Check relocation against local STT_GNU_IFUNC symbol. */
1578 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1580 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1584 /* Fake a STT_GNU_IFUNC symbol. */
1585 h
->type
= STT_GNU_IFUNC
;
1588 h
->forced_local
= 1;
1589 h
->root
.type
= bfd_link_hash_defined
;
1597 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1598 while (h
->root
.type
== bfd_link_hash_indirect
1599 || h
->root
.type
== bfd_link_hash_warning
)
1600 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1603 eh
= (struct elf_i386_link_hash_entry
*) h
;
1618 if (htab
->elf
.dynobj
== NULL
)
1619 htab
->elf
.dynobj
= abfd
;
1620 /* Create the ifunc sections for static executables. */
1621 if (h
->type
== STT_GNU_IFUNC
1622 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1628 /* It is referenced by a non-shared object. */
1630 h
->root
.non_ir_ref
= 1;
1632 if (h
->type
== STT_GNU_IFUNC
)
1633 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1634 |= elf_gnu_symbol_ifunc
;
1637 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1638 symtab_hdr
, sym_hashes
,
1639 &r_type
, GOT_UNKNOWN
,
1640 rel
, rel_end
, h
, r_symndx
))
1646 htab
->tls_ldm_got
.refcount
+= 1;
1650 /* This symbol requires a procedure linkage table entry. We
1651 actually build the entry in adjust_dynamic_symbol,
1652 because this might be a case of linking PIC code which is
1653 never referenced by a dynamic object, in which case we
1654 don't need to generate a procedure linkage table entry
1657 /* If this is a local symbol, we resolve it directly without
1658 creating a procedure linkage table entry. */
1662 eh
->has_got_reloc
= 1;
1664 h
->plt
.refcount
+= 1;
1671 case R_386_TLS_IE_32
:
1673 case R_386_TLS_GOTIE
:
1674 if (!bfd_link_executable (info
))
1675 info
->flags
|= DF_STATIC_TLS
;
1681 case R_386_TLS_GOTDESC
:
1682 case R_386_TLS_DESC_CALL
:
1683 /* This symbol requires a global offset table entry. */
1685 int tls_type
, old_tls_type
;
1692 tls_type
= GOT_NORMAL
;
1694 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1695 case R_386_TLS_GOTDESC
:
1696 case R_386_TLS_DESC_CALL
:
1697 tls_type
= GOT_TLS_GDESC
; break;
1698 case R_386_TLS_IE_32
:
1699 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1700 tls_type
= GOT_TLS_IE_NEG
;
1702 /* If this is a GD->IE transition, we may use either of
1703 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1704 tls_type
= GOT_TLS_IE
;
1707 case R_386_TLS_GOTIE
:
1708 tls_type
= GOT_TLS_IE_POS
; break;
1713 h
->got
.refcount
+= 1;
1714 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1718 bfd_signed_vma
*local_got_refcounts
;
1720 /* This is a global offset table entry for a local symbol. */
1721 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1722 if (local_got_refcounts
== NULL
)
1726 size
= symtab_hdr
->sh_info
;
1727 size
*= (sizeof (bfd_signed_vma
)
1728 + sizeof (bfd_vma
) + sizeof(char));
1729 local_got_refcounts
= (bfd_signed_vma
*)
1730 bfd_zalloc (abfd
, size
);
1731 if (local_got_refcounts
== NULL
)
1733 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1734 elf_i386_local_tlsdesc_gotent (abfd
)
1735 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1736 elf_i386_local_got_tls_type (abfd
)
1737 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1739 local_got_refcounts
[r_symndx
] += 1;
1740 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1743 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1744 tls_type
|= old_tls_type
;
1745 /* If a TLS symbol is accessed using IE at least once,
1746 there is no point to use dynamic model for it. */
1747 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1748 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1749 || (tls_type
& GOT_TLS_IE
) == 0))
1751 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1752 tls_type
= old_tls_type
;
1753 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1754 && GOT_TLS_GD_ANY_P (tls_type
))
1755 tls_type
|= old_tls_type
;
1759 name
= h
->root
.root
.string
;
1761 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1763 (*_bfd_error_handler
)
1764 (_("%B: `%s' accessed both as normal and "
1765 "thread local symbol"),
1767 bfd_set_error (bfd_error_bad_value
);
1772 if (old_tls_type
!= tls_type
)
1775 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1777 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1785 if (htab
->elf
.sgot
== NULL
)
1787 if (htab
->elf
.dynobj
== NULL
)
1788 htab
->elf
.dynobj
= abfd
;
1789 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
1792 if (r_type
!= R_386_TLS_IE
)
1795 eh
->has_got_reloc
= 1;
1800 case R_386_TLS_LE_32
:
1803 eh
->has_got_reloc
= 1;
1804 if (bfd_link_executable (info
))
1806 info
->flags
|= DF_STATIC_TLS
;
1811 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
1812 eh
->has_non_got_reloc
= 1;
1814 /* STT_GNU_IFUNC symbol must go through PLT even if it is
1815 locally defined and undefined symbol may turn out to be
1816 a STT_GNU_IFUNC symbol later. */
1818 && (bfd_link_executable (info
)
1819 || ((h
->type
== STT_GNU_IFUNC
1820 || h
->root
.type
== bfd_link_hash_undefweak
1821 || h
->root
.type
== bfd_link_hash_undefined
)
1822 && SYMBOLIC_BIND (info
, h
))))
1824 /* If this reloc is in a read-only section, we might
1825 need a copy reloc. We can't check reliably at this
1826 stage whether the section is read-only, as input
1827 sections have not yet been mapped to output sections.
1828 Tentatively set the flag for now, and correct in
1829 adjust_dynamic_symbol. */
1832 /* We may need a .plt entry if the function this reloc
1833 refers to is in a shared lib. */
1834 h
->plt
.refcount
+= 1;
1835 if (r_type
== R_386_PC32
)
1837 /* Since something like ".long foo - ." may be used
1838 as pointer, make sure that PLT is used if foo is
1839 a function defined in a shared library. */
1840 if ((sec
->flags
& SEC_CODE
) == 0)
1841 h
->pointer_equality_needed
= 1;
1845 h
->pointer_equality_needed
= 1;
1846 /* R_386_32 can be resolved at run-time. */
1847 if (r_type
== R_386_32
1848 && (sec
->flags
& SEC_READONLY
) == 0)
1849 eh
->func_pointer_refcount
+= 1;
1855 /* If we are creating a shared library, and this is a reloc
1856 against a global symbol, or a non PC relative reloc
1857 against a local symbol, then we need to copy the reloc
1858 into the shared library. However, if we are linking with
1859 -Bsymbolic, we do not need to copy a reloc against a
1860 global symbol which is defined in an object we are
1861 including in the link (i.e., DEF_REGULAR is set). At
1862 this point we have not seen all the input files, so it is
1863 possible that DEF_REGULAR is not set now but will be set
1864 later (it is never cleared). In case of a weak definition,
1865 DEF_REGULAR may be cleared later by a strong definition in
1866 a shared library. We account for that possibility below by
1867 storing information in the relocs_copied field of the hash
1868 table entry. A similar situation occurs when creating
1869 shared libraries and symbol visibility changes render the
1872 If on the other hand, we are creating an executable, we
1873 may need to keep relocations for symbols satisfied by a
1874 dynamic library if we manage to avoid copy relocs for the
1876 if ((bfd_link_pic (info
)
1877 && (sec
->flags
& SEC_ALLOC
) != 0
1878 && (r_type
!= R_386_PC32
1880 && (! (bfd_link_pie (info
)
1881 || SYMBOLIC_BIND (info
, h
))
1882 || h
->root
.type
== bfd_link_hash_defweak
1883 || !h
->def_regular
))))
1884 || (ELIMINATE_COPY_RELOCS
1885 && !bfd_link_pic (info
)
1886 && (sec
->flags
& SEC_ALLOC
) != 0
1888 && (h
->root
.type
== bfd_link_hash_defweak
1889 || !h
->def_regular
)))
1891 struct elf_dyn_relocs
*p
;
1892 struct elf_dyn_relocs
**head
;
1894 /* We must copy these reloc types into the output file.
1895 Create a reloc section in dynobj and make room for
1899 if (htab
->elf
.dynobj
== NULL
)
1900 htab
->elf
.dynobj
= abfd
;
1902 sreloc
= _bfd_elf_make_dynamic_reloc_section
1903 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1909 /* If this is a global symbol, we count the number of
1910 relocations we need for this symbol. */
1913 head
= &eh
->dyn_relocs
;
1917 /* Track dynamic relocs needed for local syms too.
1918 We really need local syms available to do this
1923 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1928 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1932 vpp
= &elf_section_data (s
)->local_dynrel
;
1933 head
= (struct elf_dyn_relocs
**)vpp
;
1937 if (p
== NULL
|| p
->sec
!= sec
)
1939 bfd_size_type amt
= sizeof *p
;
1940 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
1952 /* Count size relocation as PC-relative relocation. */
1953 if (r_type
== R_386_PC32
|| size_reloc
)
1958 /* This relocation describes the C++ object vtable hierarchy.
1959 Reconstruct it for later use during GC. */
1960 case R_386_GNU_VTINHERIT
:
1961 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1965 /* This relocation describes which C++ vtable entries are actually
1966 used. Record for later use during GC. */
1967 case R_386_GNU_VTENTRY
:
1968 BFD_ASSERT (h
!= NULL
);
1970 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1980 && h
->plt
.refcount
> 0
1981 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
1982 || h
->got
.refcount
> 0)
1983 && htab
->plt_got
== NULL
)
1985 /* Create the GOT procedure linkage table. */
1986 unsigned int plt_got_align
;
1987 const struct elf_backend_data
*bed
;
1989 bed
= get_elf_backend_data (info
->output_bfd
);
1990 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
1991 && (sizeof (elf_i386_got_plt_entry
)
1992 == sizeof (elf_i386_pic_got_plt_entry
)));
1995 if (htab
->elf
.dynobj
== NULL
)
1996 htab
->elf
.dynobj
= abfd
;
1998 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2000 (bed
->dynamic_sec_flags
2005 if (htab
->plt_got
== NULL
2006 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2012 if ((r_type
== R_386_GOT32
|| r_type
== R_386_GOT32X
)
2013 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2014 sec
->need_convert_load
= 1;
2020 /* Return the section that should be marked against GC for a given
2024 elf_i386_gc_mark_hook (asection
*sec
,
2025 struct bfd_link_info
*info
,
2026 Elf_Internal_Rela
*rel
,
2027 struct elf_link_hash_entry
*h
,
2028 Elf_Internal_Sym
*sym
)
2031 switch (ELF32_R_TYPE (rel
->r_info
))
2033 case R_386_GNU_VTINHERIT
:
2034 case R_386_GNU_VTENTRY
:
2038 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2041 /* Remove undefined weak symbol from the dynamic symbol table if it
2042 is resolved to 0. */
2045 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2046 struct elf_link_hash_entry
*h
)
2048 if (h
->dynindx
!= -1
2049 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2050 elf_i386_hash_entry (h
)))
2053 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2059 /* Adjust a symbol defined by a dynamic object and referenced by a
2060 regular object. The current definition is in some section of the
2061 dynamic object, but we're not including those sections. We have to
2062 change the definition to something the rest of the link can
2066 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2067 struct elf_link_hash_entry
*h
)
2069 struct elf_i386_link_hash_table
*htab
;
2071 struct elf_i386_link_hash_entry
*eh
;
2072 struct elf_dyn_relocs
*p
;
2074 /* STT_GNU_IFUNC symbol must go through PLT. */
2075 if (h
->type
== STT_GNU_IFUNC
)
2077 /* All local STT_GNU_IFUNC references must be treate as local
2078 calls via local PLT. */
2080 && SYMBOL_CALLS_LOCAL (info
, h
))
2082 bfd_size_type pc_count
= 0, count
= 0;
2083 struct elf_dyn_relocs
**pp
;
2085 eh
= (struct elf_i386_link_hash_entry
*) h
;
2086 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2088 pc_count
+= p
->pc_count
;
2089 p
->count
-= p
->pc_count
;
2098 if (pc_count
|| count
)
2102 if (h
->plt
.refcount
<= 0)
2103 h
->plt
.refcount
= 1;
2105 h
->plt
.refcount
+= 1;
2109 if (h
->plt
.refcount
<= 0)
2111 h
->plt
.offset
= (bfd_vma
) -1;
2117 /* If this is a function, put it in the procedure linkage table. We
2118 will fill in the contents of the procedure linkage table later,
2119 when we know the address of the .got section. */
2120 if (h
->type
== STT_FUNC
2123 if (h
->plt
.refcount
<= 0
2124 || SYMBOL_CALLS_LOCAL (info
, h
)
2125 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2126 && h
->root
.type
== bfd_link_hash_undefweak
))
2128 /* This case can occur if we saw a PLT32 reloc in an input
2129 file, but the symbol was never referred to by a dynamic
2130 object, or if all references were garbage collected. In
2131 such a case, we don't actually need to build a procedure
2132 linkage table, and we can just do a PC32 reloc instead. */
2133 h
->plt
.offset
= (bfd_vma
) -1;
2140 /* It's possible that we incorrectly decided a .plt reloc was
2141 needed for an R_386_PC32 reloc to a non-function sym in
2142 check_relocs. We can't decide accurately between function and
2143 non-function syms in check-relocs; Objects loaded later in
2144 the link may change h->type. So fix it now. */
2145 h
->plt
.offset
= (bfd_vma
) -1;
2147 /* If this is a weak symbol, and there is a real definition, the
2148 processor independent code will have arranged for us to see the
2149 real definition first, and we can just use the same value. */
2150 if (h
->u
.weakdef
!= NULL
)
2152 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2153 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2154 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2155 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2156 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2157 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2161 /* This is a reference to a symbol defined by a dynamic object which
2162 is not a function. */
2164 /* If we are creating a shared library, we must presume that the
2165 only references to the symbol are via the global offset table.
2166 For such cases we need not do anything here; the relocations will
2167 be handled correctly by relocate_section. */
2168 if (!bfd_link_executable (info
))
2171 /* If there are no references to this symbol that do not use the
2172 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2174 eh
= (struct elf_i386_link_hash_entry
*) h
;
2175 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2178 /* If -z nocopyreloc was given, we won't generate them either. */
2179 if (info
->nocopyreloc
)
2185 htab
= elf_i386_hash_table (info
);
2189 /* If there aren't any dynamic relocs in read-only sections nor
2190 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2191 avoid the copy reloc. This doesn't work on VxWorks, where we can
2192 not have dynamic relocations (other than copy and jump slot
2193 relocations) in an executable. */
2194 if (ELIMINATE_COPY_RELOCS
2196 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2198 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2200 s
= p
->sec
->output_section
;
2201 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2212 /* We must allocate the symbol in our .dynbss section, which will
2213 become part of the .bss section of the executable. There will be
2214 an entry for this symbol in the .dynsym section. The dynamic
2215 object will contain position independent code, so all references
2216 from the dynamic object to this symbol will go through the global
2217 offset table. The dynamic linker will use the .dynsym entry to
2218 determine the address it must put in the global offset table, so
2219 both the dynamic object and the regular object will refer to the
2220 same memory location for the variable. */
2222 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2223 copy the initial value out of the dynamic object and into the
2224 runtime process image. */
2225 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2227 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2233 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2236 /* Allocate space in .plt, .got and associated reloc sections for
2240 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2242 struct bfd_link_info
*info
;
2243 struct elf_i386_link_hash_table
*htab
;
2244 struct elf_i386_link_hash_entry
*eh
;
2245 struct elf_dyn_relocs
*p
;
2246 unsigned plt_entry_size
;
2247 bfd_boolean resolved_to_zero
;
2249 if (h
->root
.type
== bfd_link_hash_indirect
)
2252 eh
= (struct elf_i386_link_hash_entry
*) h
;
2254 info
= (struct bfd_link_info
*) inf
;
2255 htab
= elf_i386_hash_table (info
);
2259 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2261 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2263 /* Clear the reference count of function pointer relocations if
2264 symbol isn't a normal function. */
2265 if (h
->type
!= STT_FUNC
)
2266 eh
->func_pointer_refcount
= 0;
2268 /* We can't use the GOT PLT if pointer equality is needed since
2269 finish_dynamic_symbol won't clear symbol value and the dynamic
2270 linker won't update the GOT slot. We will get into an infinite
2271 loop at run-time. */
2272 if (htab
->plt_got
!= NULL
2273 && h
->type
!= STT_GNU_IFUNC
2274 && !h
->pointer_equality_needed
2275 && h
->plt
.refcount
> 0
2276 && h
->got
.refcount
> 0)
2278 /* Don't use the regular PLT if there are both GOT and GOTPLT
2280 h
->plt
.offset
= (bfd_vma
) -1;
2282 /* Use the GOT PLT. */
2283 eh
->plt_got
.refcount
= 1;
2286 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2287 here if it is defined and referenced in a non-shared object. */
2288 if (h
->type
== STT_GNU_IFUNC
2290 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2291 &htab
->readonly_dynrelocs_against_ifunc
,
2294 /* Don't create the PLT entry if there are only function pointer
2295 relocations which can be resolved at run-time. */
2296 else if (htab
->elf
.dynamic_sections_created
2297 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2298 || eh
->plt_got
.refcount
> 0))
2300 bfd_boolean use_plt_got
;
2302 /* Clear the reference count of function pointer relocations
2304 eh
->func_pointer_refcount
= 0;
2306 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2308 /* Don't use the regular PLT for DF_BIND_NOW. */
2309 h
->plt
.offset
= (bfd_vma
) -1;
2311 /* Use the GOT PLT. */
2312 h
->got
.refcount
= 1;
2313 eh
->plt_got
.refcount
= 1;
2316 use_plt_got
= eh
->plt_got
.refcount
> 0;
2318 /* Make sure this symbol is output as a dynamic symbol.
2319 Undefined weak syms won't yet be marked as dynamic. */
2320 if (h
->dynindx
== -1
2322 && !resolved_to_zero
)
2324 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2328 if (bfd_link_pic (info
)
2329 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2331 asection
*s
= htab
->elf
.splt
;
2332 asection
*got_s
= htab
->plt_got
;
2334 /* If this is the first .plt entry, make room for the special
2335 first entry. The .plt section is used by prelink to undo
2336 prelinking for dynamic relocations. */
2338 s
->size
= plt_entry_size
;
2341 eh
->plt_got
.offset
= got_s
->size
;
2343 h
->plt
.offset
= s
->size
;
2345 /* If this symbol is not defined in a regular file, and we are
2346 not generating a shared library, then set the symbol to this
2347 location in the .plt. This is required to make function
2348 pointers compare as equal between the normal executable and
2349 the shared library. */
2350 if (! bfd_link_pic (info
)
2355 /* We need to make a call to the entry of the GOT PLT
2356 instead of regular PLT entry. */
2357 h
->root
.u
.def
.section
= got_s
;
2358 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2362 h
->root
.u
.def
.section
= s
;
2363 h
->root
.u
.def
.value
= h
->plt
.offset
;
2367 /* Make room for this entry. */
2369 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2372 s
->size
+= plt_entry_size
;
2374 /* We also need to make an entry in the .got.plt section,
2375 which will be placed in the .got section by the linker
2377 htab
->elf
.sgotplt
->size
+= 4;
2379 /* There should be no PLT relocation against resolved
2380 undefined weak symbol in executable. */
2381 if (!resolved_to_zero
)
2383 /* We also need to make an entry in the .rel.plt
2385 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2386 htab
->elf
.srelplt
->reloc_count
++;
2390 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2391 && !bfd_link_pic (info
))
2393 /* VxWorks has a second set of relocations for each PLT entry
2394 in executables. They go in a separate relocation section,
2395 which is processed by the kernel loader. */
2397 /* There are two relocations for the initial PLT entry: an
2398 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2399 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2401 if (h
->plt
.offset
== plt_entry_size
)
2402 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2404 /* There are two extra relocations for each subsequent PLT entry:
2405 an R_386_32 relocation for the GOT entry, and an R_386_32
2406 relocation for the PLT entry. */
2408 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2413 eh
->plt_got
.offset
= (bfd_vma
) -1;
2414 h
->plt
.offset
= (bfd_vma
) -1;
2420 eh
->plt_got
.offset
= (bfd_vma
) -1;
2421 h
->plt
.offset
= (bfd_vma
) -1;
2425 eh
->tlsdesc_got
= (bfd_vma
) -1;
2427 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2428 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2429 if (h
->got
.refcount
> 0
2430 && bfd_link_executable (info
)
2432 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2433 h
->got
.offset
= (bfd_vma
) -1;
2434 else if (h
->got
.refcount
> 0)
2438 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2440 /* Make sure this symbol is output as a dynamic symbol.
2441 Undefined weak syms won't yet be marked as dynamic. */
2442 if (h
->dynindx
== -1
2444 && !resolved_to_zero
)
2446 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2451 if (GOT_TLS_GDESC_P (tls_type
))
2453 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2454 - elf_i386_compute_jump_table_size (htab
);
2455 htab
->elf
.sgotplt
->size
+= 8;
2456 h
->got
.offset
= (bfd_vma
) -2;
2458 if (! GOT_TLS_GDESC_P (tls_type
)
2459 || GOT_TLS_GD_P (tls_type
))
2461 h
->got
.offset
= s
->size
;
2463 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2464 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2467 dyn
= htab
->elf
.dynamic_sections_created
;
2468 /* R_386_TLS_IE_32 needs one dynamic relocation,
2469 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2470 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2471 need two), R_386_TLS_GD needs one if local symbol and two if
2472 global. No dynamic relocation against resolved undefined weak
2473 symbol in executable. */
2474 if (tls_type
== GOT_TLS_IE_BOTH
)
2475 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2476 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2477 || (tls_type
& GOT_TLS_IE
))
2478 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2479 else if (GOT_TLS_GD_P (tls_type
))
2480 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2481 else if (! GOT_TLS_GDESC_P (tls_type
)
2482 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2483 && !resolved_to_zero
)
2484 || h
->root
.type
!= bfd_link_hash_undefweak
)
2485 && (bfd_link_pic (info
)
2486 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2487 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2488 if (GOT_TLS_GDESC_P (tls_type
))
2489 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2492 h
->got
.offset
= (bfd_vma
) -1;
2494 if (eh
->dyn_relocs
== NULL
)
2497 /* In the shared -Bsymbolic case, discard space allocated for
2498 dynamic pc-relative relocs against symbols which turn out to be
2499 defined in regular objects. For the normal shared case, discard
2500 space for pc-relative relocs that have become local due to symbol
2501 visibility changes. */
2503 if (bfd_link_pic (info
))
2505 /* The only reloc that uses pc_count is R_386_PC32, which will
2506 appear on a call or on something like ".long foo - .". We
2507 want calls to protected symbols to resolve directly to the
2508 function rather than going via the plt. If people want
2509 function pointer comparisons to work as expected then they
2510 should avoid writing assembly like ".long foo - .". */
2511 if (SYMBOL_CALLS_LOCAL (info
, h
))
2513 struct elf_dyn_relocs
**pp
;
2515 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2517 p
->count
-= p
->pc_count
;
2526 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2528 struct elf_dyn_relocs
**pp
;
2529 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2531 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2538 /* Also discard relocs on undefined weak syms with non-default
2539 visibility or in PIE. */
2540 if (eh
->dyn_relocs
!= NULL
2541 && h
->root
.type
== bfd_link_hash_undefweak
)
2543 /* Undefined weak symbol is never bound locally in shared
2545 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2546 || resolved_to_zero
)
2550 /* Keep dynamic non-GOT/non-PLT relocation so that we
2551 can branch to 0 without PLT. */
2552 struct elf_dyn_relocs
**pp
;
2554 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2555 if (p
->pc_count
== 0)
2559 /* Remove non-R_386_PC32 relocation. */
2560 p
->count
= p
->pc_count
;
2564 if (eh
->dyn_relocs
!= NULL
)
2566 /* Make sure undefined weak symbols are output
2567 as dynamic symbols in PIEs for dynamic non-GOT
2568 non-PLT reloations. */
2569 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2574 eh
->dyn_relocs
= NULL
;
2576 else if (h
->dynindx
== -1
2577 && !h
->forced_local
)
2579 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2584 else if (ELIMINATE_COPY_RELOCS
)
2586 /* For the non-shared case, discard space for relocs against
2587 symbols which turn out to need copy relocs or are not
2588 dynamic. Keep dynamic relocations for run-time function
2589 pointer initialization. */
2591 if ((!h
->non_got_ref
2592 || eh
->func_pointer_refcount
> 0
2593 || (h
->root
.type
== bfd_link_hash_undefweak
2594 && !resolved_to_zero
))
2597 || (htab
->elf
.dynamic_sections_created
2598 && (h
->root
.type
== bfd_link_hash_undefweak
2599 || h
->root
.type
== bfd_link_hash_undefined
))))
2601 /* Make sure this symbol is output as a dynamic symbol.
2602 Undefined weak syms won't yet be marked as dynamic. */
2603 if (h
->dynindx
== -1
2605 && !resolved_to_zero
)
2607 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2611 /* If that succeeded, we know we'll be keeping all the
2613 if (h
->dynindx
!= -1)
2617 eh
->dyn_relocs
= NULL
;
2618 eh
->func_pointer_refcount
= 0;
2623 /* Finally, allocate space. */
2624 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2628 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2630 BFD_ASSERT (sreloc
!= NULL
);
2631 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2637 /* Allocate space in .plt, .got and associated reloc sections for
2638 local dynamic relocs. */
2641 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2643 struct elf_link_hash_entry
*h
2644 = (struct elf_link_hash_entry
*) *slot
;
2646 if (h
->type
!= STT_GNU_IFUNC
2650 || h
->root
.type
!= bfd_link_hash_defined
)
2653 return elf_i386_allocate_dynrelocs (h
, inf
);
2656 /* Find any dynamic relocs that apply to read-only sections. */
2659 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2661 struct elf_i386_link_hash_entry
*eh
;
2662 struct elf_dyn_relocs
*p
;
2664 /* Skip local IFUNC symbols. */
2665 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2668 eh
= (struct elf_i386_link_hash_entry
*) h
;
2669 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2671 asection
*s
= p
->sec
->output_section
;
2673 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2675 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2677 info
->flags
|= DF_TEXTREL
;
2679 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2680 || info
->error_textrel
)
2681 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2682 p
->sec
->owner
, h
->root
.root
.string
,
2685 /* Not an error, just cut short the traversal. */
2692 /* With the local symbol, foo, we convert
2693 mov foo@GOT[(%reg1)], %reg2
2695 lea foo[@GOTOFF(%reg1)], %reg2
2697 call/jmp *foo@GOT[(%reg)]
2699 nop call foo/jmp foo nop
2700 When PIC is false, convert
2701 test %reg1, foo@GOT[(%reg2)]
2705 binop foo@GOT[(%reg1)], %reg2
2708 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2712 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
2713 struct bfd_link_info
*link_info
)
2715 Elf_Internal_Shdr
*symtab_hdr
;
2716 Elf_Internal_Rela
*internal_relocs
;
2717 Elf_Internal_Rela
*irel
, *irelend
;
2719 struct elf_i386_link_hash_table
*htab
;
2720 bfd_boolean changed_contents
;
2721 bfd_boolean changed_relocs
;
2723 bfd_signed_vma
*local_got_refcounts
;
2725 /* Don't even try to convert non-ELF outputs. */
2726 if (!is_elf_hash_table (link_info
->hash
))
2729 /* Nothing to do if there is no need or no output. */
2730 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2731 || sec
->need_convert_load
== 0
2732 || bfd_is_abs_section (sec
->output_section
))
2735 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2737 /* Load the relocations for this section. */
2738 internal_relocs
= (_bfd_elf_link_read_relocs
2739 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2740 link_info
->keep_memory
));
2741 if (internal_relocs
== NULL
)
2744 htab
= elf_i386_hash_table (link_info
);
2745 changed_contents
= FALSE
;
2746 changed_relocs
= FALSE
;
2747 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2749 is_pic
= bfd_link_pic (link_info
);
2751 /* Get the section contents. */
2752 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2753 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2756 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2760 irelend
= internal_relocs
+ sec
->reloc_count
;
2761 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2763 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2764 unsigned int r_symndx
= ELF32_R_SYM (irel
->r_info
);
2766 struct elf_link_hash_entry
*h
;
2767 unsigned int opcode
;
2770 bfd_boolean baseless
;
2771 Elf_Internal_Sym
*isym
;
2772 unsigned int addend
;
2775 bfd_boolean to_reloc_32
;
2777 if (r_type
!= R_386_GOT32
&& r_type
!= R_386_GOT32X
)
2780 roff
= irel
->r_offset
;
2784 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
2785 addend
= bfd_get_32 (abfd
, contents
+ roff
);
2789 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2790 baseless
= (modrm
& 0xc7) == 0x5;
2792 if (r_type
== R_386_GOT32X
&& baseless
&& is_pic
)
2794 /* For PIC, disallow R_386_GOT32X without a base register
2795 since we don't know what the GOT base is. Allow
2796 R_386_GOT32 for existing object files. */
2799 if (r_symndx
< symtab_hdr
->sh_info
)
2801 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
2803 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
2807 indx
= r_symndx
- symtab_hdr
->sh_info
;
2808 h
= elf_sym_hashes (abfd
)[indx
];
2809 BFD_ASSERT (h
!= NULL
);
2810 name
= h
->root
.root
.string
;
2813 (*_bfd_error_handler
)
2814 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
2819 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
2821 /* Convert mov to lea since it has been done for a while. */
2824 /* Only convert R_386_GOT32X relocation for call, jmp or
2825 one of adc, add, and, cmp, or, sbb, sub, test, xor
2827 if (r_type
!= R_386_GOT32X
)
2831 /* Convert to R_386_32 if PIC is false or there is no base
2833 to_reloc_32
= !is_pic
|| baseless
;
2835 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
2836 referred to by the reloc. */
2837 if (r_symndx
< symtab_hdr
->sh_info
)
2839 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2842 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2843 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2847 if (opcode
== 0x0ff)
2848 /* Convert "call/jmp *foo@GOT[(%reg)]". */
2849 goto convert_branch
;
2851 /* Convert "mov foo@GOT[(%reg1)], %reg2",
2852 "test %reg1, foo@GOT(%reg2)" and
2853 "binop foo@GOT[(%reg1)], %reg2". */
2857 indx
= r_symndx
- symtab_hdr
->sh_info
;
2858 h
= elf_sym_hashes (abfd
)[indx
];
2859 BFD_ASSERT (h
!= NULL
);
2861 while (h
->root
.type
== bfd_link_hash_indirect
2862 || h
->root
.type
== bfd_link_hash_warning
)
2863 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2865 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2866 if (h
->type
== STT_GNU_IFUNC
)
2869 /* Undefined weak symbol is only bound locally in executable
2870 and its reference is resolved as 0. */
2871 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
2872 elf_i386_hash_entry (h
)))
2876 /* No direct branch to 0 for PIC. */
2880 goto convert_branch
;
2884 /* We can convert load of address 0 to R_386_32. */
2892 /* We have "call/jmp *foo@GOT[(%reg)]". */
2893 if ((h
->root
.type
== bfd_link_hash_defined
2894 || h
->root
.type
== bfd_link_hash_defweak
)
2895 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2897 /* The function is locally defined. */
2899 /* Convert R_386_GOT32X to R_386_PC32. */
2900 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
2902 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2905 nop
= link_info
->call_nop_byte
;
2906 if (link_info
->call_nop_as_suffix
)
2908 nop_offset
= roff
+ 3;
2909 irel
->r_offset
-= 1;
2912 nop_offset
= roff
- 2;
2916 /* Convert to "jmp foo nop". */
2919 nop_offset
= roff
+ 3;
2920 irel
->r_offset
-= 1;
2923 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2924 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2925 /* When converting to PC-relative relocation, we
2926 need to adjust addend by -4. */
2927 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
2928 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
2932 if (h
->got
.refcount
> 0)
2933 h
->got
.refcount
-= 1;
2937 if (local_got_refcounts
!= NULL
2938 && local_got_refcounts
[r_symndx
] > 0)
2939 local_got_refcounts
[r_symndx
] -= 1;
2942 changed_contents
= TRUE
;
2943 changed_relocs
= TRUE
;
2948 /* We have "mov foo@GOT[(%re1g)], %reg2",
2949 "test %reg1, foo@GOT(%reg2)" and
2950 "binop foo@GOT[(%reg1)], %reg2".
2952 Avoid optimizing _DYNAMIC since ld.so may use its
2953 link-time address. */
2954 if (h
== htab
->elf
.hdynamic
)
2957 /* def_regular is set by an assignment in a linker script in
2958 bfd_elf_record_link_assignment. */
2960 || h
->root
.type
== bfd_link_hash_defined
2961 || h
->root
.type
== bfd_link_hash_defweak
)
2962 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2969 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
2970 "mov $foo, %reg2" with R_386_32. */
2972 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2973 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2978 /* Convert "mov foo@GOT(%reg1), %reg2" to
2979 "lea foo@GOTOFF(%reg1), %reg2". */
2980 r_type
= R_386_GOTOFF
;
2986 /* Only R_386_32 is supported. */
2992 /* Convert "test %reg1, foo@GOT(%reg2)" to
2993 "test $foo, %reg1". */
2994 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2999 /* Convert "binop foo@GOT(%reg1), %reg2" to
3000 "binop $foo, %reg2". */
3002 | (modrm
& 0x38) >> 3
3006 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3010 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3011 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3015 if (h
->got
.refcount
> 0)
3016 h
->got
.refcount
-= 1;
3020 if (local_got_refcounts
!= NULL
3021 && local_got_refcounts
[r_symndx
] > 0)
3022 local_got_refcounts
[r_symndx
] -= 1;
3025 changed_contents
= TRUE
;
3026 changed_relocs
= TRUE
;
3031 if (contents
!= NULL
3032 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3034 if (!changed_contents
&& !link_info
->keep_memory
)
3038 /* Cache the section contents for elf_link_input_bfd. */
3039 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3043 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3045 if (!changed_relocs
)
3046 free (internal_relocs
);
3048 elf_section_data (sec
)->relocs
= internal_relocs
;
3054 if (contents
!= NULL
3055 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3057 if (internal_relocs
!= NULL
3058 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3059 free (internal_relocs
);
3063 /* Set the sizes of the dynamic sections. */
3066 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3068 struct elf_i386_link_hash_table
*htab
;
3074 htab
= elf_i386_hash_table (info
);
3077 dynobj
= htab
->elf
.dynobj
;
3081 if (htab
->elf
.dynamic_sections_created
)
3083 /* Set the contents of the .interp section to the interpreter. */
3084 if (bfd_link_executable (info
) && !info
->nointerp
)
3086 s
= bfd_get_linker_section (dynobj
, ".interp");
3089 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3090 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3095 /* Set up .got offsets for local syms, and space for local dynamic
3097 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3099 bfd_signed_vma
*local_got
;
3100 bfd_signed_vma
*end_local_got
;
3101 char *local_tls_type
;
3102 bfd_vma
*local_tlsdesc_gotent
;
3103 bfd_size_type locsymcount
;
3104 Elf_Internal_Shdr
*symtab_hdr
;
3107 if (! is_i386_elf (ibfd
))
3110 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3112 struct elf_dyn_relocs
*p
;
3114 if (!elf_i386_convert_load (ibfd
, s
, info
))
3117 for (p
= ((struct elf_dyn_relocs
*)
3118 elf_section_data (s
)->local_dynrel
);
3122 if (!bfd_is_abs_section (p
->sec
)
3123 && bfd_is_abs_section (p
->sec
->output_section
))
3125 /* Input section has been discarded, either because
3126 it is a copy of a linkonce section or due to
3127 linker script /DISCARD/, so we'll be discarding
3130 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3131 && strcmp (p
->sec
->output_section
->name
,
3134 /* Relocations in vxworks .tls_vars sections are
3135 handled specially by the loader. */
3137 else if (p
->count
!= 0)
3139 srel
= elf_section_data (p
->sec
)->sreloc
;
3140 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3141 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3142 && (info
->flags
& DF_TEXTREL
) == 0)
3144 info
->flags
|= DF_TEXTREL
;
3145 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3146 || info
->error_textrel
)
3147 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3148 p
->sec
->owner
, p
->sec
);
3154 local_got
= elf_local_got_refcounts (ibfd
);
3158 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3159 locsymcount
= symtab_hdr
->sh_info
;
3160 end_local_got
= local_got
+ locsymcount
;
3161 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3162 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3164 srel
= htab
->elf
.srelgot
;
3165 for (; local_got
< end_local_got
;
3166 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3168 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3171 if (GOT_TLS_GDESC_P (*local_tls_type
))
3173 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3174 - elf_i386_compute_jump_table_size (htab
);
3175 htab
->elf
.sgotplt
->size
+= 8;
3176 *local_got
= (bfd_vma
) -2;
3178 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3179 || GOT_TLS_GD_P (*local_tls_type
))
3181 *local_got
= s
->size
;
3183 if (GOT_TLS_GD_P (*local_tls_type
)
3184 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3187 if (bfd_link_pic (info
)
3188 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3189 || (*local_tls_type
& GOT_TLS_IE
))
3191 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3192 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3193 else if (GOT_TLS_GD_P (*local_tls_type
)
3194 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3195 srel
->size
+= sizeof (Elf32_External_Rel
);
3196 if (GOT_TLS_GDESC_P (*local_tls_type
))
3197 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3201 *local_got
= (bfd_vma
) -1;
3205 if (htab
->tls_ldm_got
.refcount
> 0)
3207 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3209 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3210 htab
->elf
.sgot
->size
+= 8;
3211 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3214 htab
->tls_ldm_got
.offset
= -1;
3216 /* Allocate global sym .plt and .got entries, and space for global
3217 sym dynamic relocs. */
3218 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3220 /* Allocate .plt and .got entries, and space for local symbols. */
3221 htab_traverse (htab
->loc_hash_table
,
3222 elf_i386_allocate_local_dynrelocs
,
3225 /* For every jump slot reserved in the sgotplt, reloc_count is
3226 incremented. However, when we reserve space for TLS descriptors,
3227 it's not incremented, so in order to compute the space reserved
3228 for them, it suffices to multiply the reloc count by the jump
3231 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3232 so that R_386_IRELATIVE entries come last. */
3233 if (htab
->elf
.srelplt
)
3235 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3236 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3237 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3239 else if (htab
->elf
.irelplt
)
3240 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3243 if (htab
->elf
.sgotplt
)
3245 /* Don't allocate .got.plt section if there are no GOT nor PLT
3246 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3247 if ((htab
->elf
.hgot
== NULL
3248 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3249 && (htab
->elf
.sgotplt
->size
3250 == get_elf_backend_data (output_bfd
)->got_header_size
)
3251 && (htab
->elf
.splt
== NULL
3252 || htab
->elf
.splt
->size
== 0)
3253 && (htab
->elf
.sgot
== NULL
3254 || htab
->elf
.sgot
->size
== 0)
3255 && (htab
->elf
.iplt
== NULL
3256 || htab
->elf
.iplt
->size
== 0)
3257 && (htab
->elf
.igotplt
== NULL
3258 || htab
->elf
.igotplt
->size
== 0))
3259 htab
->elf
.sgotplt
->size
= 0;
3263 if (htab
->plt_eh_frame
!= NULL
3264 && htab
->elf
.splt
!= NULL
3265 && htab
->elf
.splt
->size
!= 0
3266 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3267 && _bfd_elf_eh_frame_present (info
))
3268 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3270 /* We now have determined the sizes of the various dynamic sections.
3271 Allocate memory for them. */
3273 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3275 bfd_boolean strip_section
= TRUE
;
3277 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3280 if (s
== htab
->elf
.splt
3281 || s
== htab
->elf
.sgot
)
3283 /* Strip this section if we don't need it; see the
3285 /* We'd like to strip these sections if they aren't needed, but if
3286 we've exported dynamic symbols from them we must leave them.
3287 It's too late to tell BFD to get rid of the symbols. */
3289 if (htab
->elf
.hplt
!= NULL
)
3290 strip_section
= FALSE
;
3292 else if (s
== htab
->elf
.sgotplt
3293 || s
== htab
->elf
.iplt
3294 || s
== htab
->elf
.igotplt
3295 || s
== htab
->plt_got
3296 || s
== htab
->plt_eh_frame
3297 || s
== htab
->sdynbss
)
3299 /* Strip these too. */
3301 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3304 && s
!= htab
->elf
.srelplt
3305 && s
!= htab
->srelplt2
)
3308 /* We use the reloc_count field as a counter if we need
3309 to copy relocs into the output file. */
3314 /* It's not one of our sections, so don't allocate space. */
3320 /* If we don't need this section, strip it from the
3321 output file. This is mostly to handle .rel.bss and
3322 .rel.plt. We must create both sections in
3323 create_dynamic_sections, because they must be created
3324 before the linker maps input sections to output
3325 sections. The linker does that before
3326 adjust_dynamic_symbol is called, and it is that
3327 function which decides whether anything needs to go
3328 into these sections. */
3330 s
->flags
|= SEC_EXCLUDE
;
3334 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3337 /* Allocate memory for the section contents. We use bfd_zalloc
3338 here in case unused entries are not reclaimed before the
3339 section's contents are written out. This should not happen,
3340 but this way if it does, we get a R_386_NONE reloc instead
3342 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3343 if (s
->contents
== NULL
)
3347 if (htab
->plt_eh_frame
!= NULL
3348 && htab
->plt_eh_frame
->contents
!= NULL
)
3350 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3351 sizeof (elf_i386_eh_frame_plt
));
3352 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3353 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3356 if (htab
->elf
.dynamic_sections_created
)
3358 /* Add some entries to the .dynamic section. We fill in the
3359 values later, in elf_i386_finish_dynamic_sections, but we
3360 must add the entries now so that we get the correct size for
3361 the .dynamic section. The DT_DEBUG entry is filled in by the
3362 dynamic linker and used by the debugger. */
3363 #define add_dynamic_entry(TAG, VAL) \
3364 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3366 if (bfd_link_executable (info
))
3368 if (!add_dynamic_entry (DT_DEBUG
, 0))
3372 if (htab
->elf
.splt
->size
!= 0)
3374 /* DT_PLTGOT is used by prelink even if there is no PLT
3376 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3379 if (htab
->elf
.srelplt
->size
!= 0)
3381 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3382 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3383 || !add_dynamic_entry (DT_JMPREL
, 0))
3390 if (!add_dynamic_entry (DT_REL
, 0)
3391 || !add_dynamic_entry (DT_RELSZ
, 0)
3392 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3395 /* If any dynamic relocs apply to a read-only section,
3396 then we need a DT_TEXTREL entry. */
3397 if ((info
->flags
& DF_TEXTREL
) == 0)
3398 elf_link_hash_traverse (&htab
->elf
,
3399 elf_i386_readonly_dynrelocs
, info
);
3401 if ((info
->flags
& DF_TEXTREL
) != 0)
3403 if (htab
->readonly_dynrelocs_against_ifunc
)
3405 info
->callbacks
->einfo
3406 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3407 bfd_set_error (bfd_error_bad_value
);
3411 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3415 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3416 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3419 #undef add_dynamic_entry
3425 elf_i386_always_size_sections (bfd
*output_bfd
,
3426 struct bfd_link_info
*info
)
3428 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3432 struct elf_link_hash_entry
*tlsbase
;
3434 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3435 "_TLS_MODULE_BASE_",
3436 FALSE
, FALSE
, FALSE
);
3438 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3440 struct elf_i386_link_hash_table
*htab
;
3441 struct bfd_link_hash_entry
*bh
= NULL
;
3442 const struct elf_backend_data
*bed
3443 = get_elf_backend_data (output_bfd
);
3445 htab
= elf_i386_hash_table (info
);
3449 if (!(_bfd_generic_link_add_one_symbol
3450 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3451 tls_sec
, 0, NULL
, FALSE
,
3452 bed
->collect
, &bh
)))
3455 htab
->tls_module_base
= bh
;
3457 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3458 tlsbase
->def_regular
= 1;
3459 tlsbase
->other
= STV_HIDDEN
;
3460 tlsbase
->root
.linker_def
= 1;
3461 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3468 /* Set the correct type for an x86 ELF section. We do this by the
3469 section name, which is a hack, but ought to work. */
3472 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3473 Elf_Internal_Shdr
*hdr
,
3478 name
= bfd_get_section_name (abfd
, sec
);
3480 /* This is an ugly, but unfortunately necessary hack that is
3481 needed when producing EFI binaries on x86. It tells
3482 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3483 containing ELF relocation info. We need this hack in order to
3484 be able to generate ELF binaries that can be translated into
3485 EFI applications (which are essentially COFF objects). Those
3486 files contain a COFF ".reloc" section inside an ELFNN object,
3487 which would normally cause BFD to segfault because it would
3488 attempt to interpret this section as containing relocation
3489 entries for section "oc". With this hack enabled, ".reloc"
3490 will be treated as a normal data section, which will avoid the
3491 segfault. However, you won't be able to create an ELFNN binary
3492 with a section named "oc" that needs relocations, but that's
3493 the kind of ugly side-effects you get when detecting section
3494 types based on their names... In practice, this limitation is
3495 unlikely to bite. */
3496 if (strcmp (name
, ".reloc") == 0)
3497 hdr
->sh_type
= SHT_PROGBITS
;
3502 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3503 executables. Rather than setting it to the beginning of the TLS
3504 section, we have to set it to the end. This function may be called
3505 multiple times, it is idempotent. */
3508 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3510 struct elf_i386_link_hash_table
*htab
;
3511 struct bfd_link_hash_entry
*base
;
3513 if (!bfd_link_executable (info
))
3516 htab
= elf_i386_hash_table (info
);
3520 base
= htab
->tls_module_base
;
3524 base
->u
.def
.value
= htab
->elf
.tls_size
;
3527 /* Return the base VMA address which should be subtracted from real addresses
3528 when resolving @dtpoff relocation.
3529 This is PT_TLS segment p_vaddr. */
3532 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3534 /* If tls_sec is NULL, we should have signalled an error already. */
3535 if (elf_hash_table (info
)->tls_sec
== NULL
)
3537 return elf_hash_table (info
)->tls_sec
->vma
;
3540 /* Return the relocation value for @tpoff relocation
3541 if STT_TLS virtual address is ADDRESS. */
3544 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3546 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3547 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3548 bfd_vma static_tls_size
;
3550 /* If tls_sec is NULL, we should have signalled an error already. */
3551 if (htab
->tls_sec
== NULL
)
3554 /* Consider special static TLS alignment requirements. */
3555 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3556 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3559 /* Relocate an i386 ELF section. */
3562 elf_i386_relocate_section (bfd
*output_bfd
,
3563 struct bfd_link_info
*info
,
3565 asection
*input_section
,
3567 Elf_Internal_Rela
*relocs
,
3568 Elf_Internal_Sym
*local_syms
,
3569 asection
**local_sections
)
3571 struct elf_i386_link_hash_table
*htab
;
3572 Elf_Internal_Shdr
*symtab_hdr
;
3573 struct elf_link_hash_entry
**sym_hashes
;
3574 bfd_vma
*local_got_offsets
;
3575 bfd_vma
*local_tlsdesc_gotents
;
3576 Elf_Internal_Rela
*rel
;
3577 Elf_Internal_Rela
*wrel
;
3578 Elf_Internal_Rela
*relend
;
3579 bfd_boolean is_vxworks_tls
;
3580 unsigned plt_entry_size
;
3582 BFD_ASSERT (is_i386_elf (input_bfd
));
3584 htab
= elf_i386_hash_table (info
);
3587 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3588 sym_hashes
= elf_sym_hashes (input_bfd
);
3589 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3590 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3591 /* We have to handle relocations in vxworks .tls_vars sections
3592 specially, because the dynamic loader is 'weird'. */
3593 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3594 && bfd_link_pic (info
)
3595 && !strcmp (input_section
->output_section
->name
,
3598 elf_i386_set_tls_module_base (info
);
3600 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3602 rel
= wrel
= relocs
;
3603 relend
= relocs
+ input_section
->reloc_count
;
3604 for (; rel
< relend
; wrel
++, rel
++)
3606 unsigned int r_type
;
3607 reloc_howto_type
*howto
;
3608 unsigned long r_symndx
;
3609 struct elf_link_hash_entry
*h
;
3610 struct elf_i386_link_hash_entry
*eh
;
3611 Elf_Internal_Sym
*sym
;
3613 bfd_vma off
, offplt
, plt_offset
;
3615 bfd_boolean unresolved_reloc
;
3616 bfd_reloc_status_type r
;
3620 asection
*resolved_plt
;
3621 bfd_boolean resolved_to_zero
;
3623 r_type
= ELF32_R_TYPE (rel
->r_info
);
3624 if (r_type
== R_386_GNU_VTINHERIT
3625 || r_type
== R_386_GNU_VTENTRY
)
3632 if ((indx
= r_type
) >= R_386_standard
3633 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3634 >= R_386_ext
- R_386_standard
)
3635 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3636 >= R_386_ext2
- R_386_ext
))
3638 (*_bfd_error_handler
)
3639 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3640 input_bfd
, input_section
, r_type
);
3641 bfd_set_error (bfd_error_bad_value
);
3644 howto
= elf_howto_table
+ indx
;
3646 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3650 unresolved_reloc
= FALSE
;
3651 if (r_symndx
< symtab_hdr
->sh_info
)
3653 sym
= local_syms
+ r_symndx
;
3654 sec
= local_sections
[r_symndx
];
3655 relocation
= (sec
->output_section
->vma
3656 + sec
->output_offset
3658 st_size
= sym
->st_size
;
3660 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3661 && ((sec
->flags
& SEC_MERGE
) != 0
3662 || (bfd_link_relocatable (info
)
3663 && sec
->output_offset
!= 0)))
3666 bfd_byte
*where
= contents
+ rel
->r_offset
;
3668 switch (howto
->size
)
3671 addend
= bfd_get_8 (input_bfd
, where
);
3672 if (howto
->pc_relative
)
3674 addend
= (addend
^ 0x80) - 0x80;
3679 addend
= bfd_get_16 (input_bfd
, where
);
3680 if (howto
->pc_relative
)
3682 addend
= (addend
^ 0x8000) - 0x8000;
3687 addend
= bfd_get_32 (input_bfd
, where
);
3688 if (howto
->pc_relative
)
3690 addend
= (addend
^ 0x80000000) - 0x80000000;
3698 if (bfd_link_relocatable (info
))
3699 addend
+= sec
->output_offset
;
3702 asection
*msec
= sec
;
3703 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3705 addend
-= relocation
;
3706 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3709 switch (howto
->size
)
3712 /* FIXME: overflow checks. */
3713 if (howto
->pc_relative
)
3715 bfd_put_8 (input_bfd
, addend
, where
);
3718 if (howto
->pc_relative
)
3720 bfd_put_16 (input_bfd
, addend
, where
);
3723 if (howto
->pc_relative
)
3725 bfd_put_32 (input_bfd
, addend
, where
);
3729 else if (!bfd_link_relocatable (info
)
3730 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3732 /* Relocate against local STT_GNU_IFUNC symbol. */
3733 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3738 /* Set STT_GNU_IFUNC symbol value. */
3739 h
->root
.u
.def
.value
= sym
->st_value
;
3740 h
->root
.u
.def
.section
= sec
;
3745 bfd_boolean warned ATTRIBUTE_UNUSED
;
3746 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3748 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3749 r_symndx
, symtab_hdr
, sym_hashes
,
3751 unresolved_reloc
, warned
, ignored
);
3755 if (sec
!= NULL
&& discarded_section (sec
))
3757 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3758 contents
+ rel
->r_offset
);
3759 wrel
->r_offset
= rel
->r_offset
;
3763 /* For ld -r, remove relocations in debug sections against
3764 sections defined in discarded sections. Not done for
3765 eh_frame editing code expects to be present. */
3766 if (bfd_link_relocatable (info
)
3767 && (input_section
->flags
& SEC_DEBUGGING
))
3773 if (bfd_link_relocatable (info
))
3780 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3781 it here if it is defined in a non-shared object. */
3783 && h
->type
== STT_GNU_IFUNC
3786 asection
*plt
, *gotplt
, *base_got
;
3790 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3792 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3793 sections because such sections are not SEC_ALLOC and
3794 thus ld.so will not process them. */
3795 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3799 else if (h
->plt
.offset
== (bfd_vma
) -1)
3802 /* STT_GNU_IFUNC symbol must go through PLT. */
3803 if (htab
->elf
.splt
!= NULL
)
3805 plt
= htab
->elf
.splt
;
3806 gotplt
= htab
->elf
.sgotplt
;
3810 plt
= htab
->elf
.iplt
;
3811 gotplt
= htab
->elf
.igotplt
;
3814 relocation
= (plt
->output_section
->vma
3815 + plt
->output_offset
+ h
->plt
.offset
);
3820 if (h
->root
.root
.string
)
3821 name
= h
->root
.root
.string
;
3823 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3825 (*_bfd_error_handler
)
3826 (_("%B: relocation %s against STT_GNU_IFUNC "
3827 "symbol `%s' isn't handled by %s"), input_bfd
,
3828 elf_howto_table
[r_type
].name
,
3829 name
, __FUNCTION__
);
3830 bfd_set_error (bfd_error_bad_value
);
3834 /* Generate dynamic relcoation only when there is a
3835 non-GOT reference in a shared object. */
3836 if (bfd_link_pic (info
) && h
->non_got_ref
)
3838 Elf_Internal_Rela outrel
;
3842 /* Need a dynamic relocation to get the real function
3844 offset
= _bfd_elf_section_offset (output_bfd
,
3848 if (offset
== (bfd_vma
) -1
3849 || offset
== (bfd_vma
) -2)
3852 outrel
.r_offset
= (input_section
->output_section
->vma
3853 + input_section
->output_offset
3856 if (h
->dynindx
== -1
3858 || bfd_link_executable (info
))
3860 /* This symbol is resolved locally. */
3861 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3862 bfd_put_32 (output_bfd
,
3863 (h
->root
.u
.def
.value
3864 + h
->root
.u
.def
.section
->output_section
->vma
3865 + h
->root
.u
.def
.section
->output_offset
),
3869 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3871 sreloc
= htab
->elf
.irelifunc
;
3872 elf_append_rel (output_bfd
, sreloc
, &outrel
);
3874 /* If this reloc is against an external symbol, we
3875 do not want to fiddle with the addend. Otherwise,
3876 we need to include the symbol value so that it
3877 becomes an addend for the dynamic reloc. For an
3878 internal symbol, we have updated addend. */
3888 base_got
= htab
->elf
.sgot
;
3889 off
= h
->got
.offset
;
3891 if (base_got
== NULL
)
3894 if (off
== (bfd_vma
) -1)
3896 /* We can't use h->got.offset here to save state, or
3897 even just remember the offset, as finish_dynamic_symbol
3898 would use that as offset into .got. */
3900 if (htab
->elf
.splt
!= NULL
)
3902 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3903 off
= (plt_index
+ 3) * 4;
3904 base_got
= htab
->elf
.sgotplt
;
3908 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3909 off
= plt_index
* 4;
3910 base_got
= htab
->elf
.igotplt
;
3913 if (h
->dynindx
== -1
3917 /* This references the local defitionion. We must
3918 initialize this entry in the global offset table.
3919 Since the offset must always be a multiple of 8,
3920 we use the least significant bit to record
3921 whether we have initialized it already.
3923 When doing a dynamic link, we create a .rela.got
3924 relocation entry to initialize the value. This
3925 is done in the finish_dynamic_symbol routine. */
3930 bfd_put_32 (output_bfd
, relocation
,
3931 base_got
->contents
+ off
);
3938 /* Adjust for static executables. */
3939 if (htab
->elf
.splt
== NULL
)
3940 relocation
+= gotplt
->output_offset
;
3944 relocation
= (base_got
->output_section
->vma
3945 + base_got
->output_offset
+ off
3946 - gotplt
->output_section
->vma
3947 - gotplt
->output_offset
);
3948 /* Adjust for static executables. */
3949 if (htab
->elf
.splt
== NULL
)
3950 relocation
+= gotplt
->output_offset
;
3956 relocation
-= (gotplt
->output_section
->vma
3957 + gotplt
->output_offset
);
3962 eh
= (struct elf_i386_link_hash_entry
*) h
;
3963 resolved_to_zero
= (eh
!= NULL
3964 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
3969 /* Avoid optimizing _DYNAMIC since ld.so may use its
3970 link-time address. */
3971 if (h
== htab
->elf
.hdynamic
)
3974 if (bfd_link_pic (info
))
3976 /* It is OK to convert mov to lea and convert indirect
3977 branch to direct branch. It is OK to convert adc,
3978 add, and, cmp, or, sbb, sub, test, xor only when PIC
3980 unsigned int opcode
, addend
;
3981 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3984 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3985 if (opcode
!= 0x8b && opcode
!= 0xff)
3989 /* Resolve "mov GOT[(%reg)], %reg",
3990 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
3991 and "binop foo@GOT[(%reg)], %reg". */
3993 || (h
->plt
.offset
== (bfd_vma
) -1
3994 && h
->got
.offset
== (bfd_vma
) -1)
3995 || htab
->elf
.sgotplt
== NULL
)
3998 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
3999 + htab
->elf
.sgotplt
->output_offset
);
4001 /* It is relative to .got.plt section. */
4002 if (h
->got
.offset
!= (bfd_vma
) -1)
4003 /* Use GOT entry. Mask off the least significant bit in
4004 GOT offset which may be set by R_386_GOT32 processing
4006 relocation
= (htab
->elf
.sgot
->output_section
->vma
4007 + htab
->elf
.sgot
->output_offset
4008 + (h
->got
.offset
& ~1) - offplt
);
4010 /* Use GOTPLT entry. */
4011 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4013 if (!bfd_link_pic (info
))
4015 /* If not PIC, add the .got.plt section address for
4016 baseless addressing. */
4018 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4019 if ((modrm
& 0xc7) == 0x5)
4020 relocation
+= offplt
;
4023 unresolved_reloc
= FALSE
;
4028 /* Relocation is to the entry for this symbol in the global
4030 if (htab
->elf
.sgot
== NULL
)
4037 off
= h
->got
.offset
;
4038 dyn
= htab
->elf
.dynamic_sections_created
;
4039 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4040 bfd_link_pic (info
),
4042 || (bfd_link_pic (info
)
4043 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4044 || (ELF_ST_VISIBILITY (h
->other
)
4045 && h
->root
.type
== bfd_link_hash_undefweak
))
4047 /* This is actually a static link, or it is a
4048 -Bsymbolic link and the symbol is defined
4049 locally, or the symbol was forced to be local
4050 because of a version file. We must initialize
4051 this entry in the global offset table. Since the
4052 offset must always be a multiple of 4, we use the
4053 least significant bit to record whether we have
4054 initialized it already.
4056 When doing a dynamic link, we create a .rel.got
4057 relocation entry to initialize the value. This
4058 is done in the finish_dynamic_symbol routine. */
4063 bfd_put_32 (output_bfd
, relocation
,
4064 htab
->elf
.sgot
->contents
+ off
);
4069 unresolved_reloc
= FALSE
;
4073 if (local_got_offsets
== NULL
)
4076 off
= local_got_offsets
[r_symndx
];
4078 /* The offset must always be a multiple of 4. We use
4079 the least significant bit to record whether we have
4080 already generated the necessary reloc. */
4085 bfd_put_32 (output_bfd
, relocation
,
4086 htab
->elf
.sgot
->contents
+ off
);
4088 if (bfd_link_pic (info
))
4091 Elf_Internal_Rela outrel
;
4093 s
= htab
->elf
.srelgot
;
4097 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4098 + htab
->elf
.sgot
->output_offset
4100 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4101 elf_append_rel (output_bfd
, s
, &outrel
);
4104 local_got_offsets
[r_symndx
] |= 1;
4108 if (off
>= (bfd_vma
) -2)
4111 relocation
= htab
->elf
.sgot
->output_section
->vma
4112 + htab
->elf
.sgot
->output_offset
+ off
4113 - htab
->elf
.sgotplt
->output_section
->vma
4114 - htab
->elf
.sgotplt
->output_offset
;
4118 /* Relocation is relative to the start of the global offset
4121 /* Check to make sure it isn't a protected function or data
4122 symbol for shared library since it may not be local when
4123 used as function address or with copy relocation. We also
4124 need to make sure that a symbol is referenced locally. */
4125 if (!bfd_link_executable (info
) && h
)
4127 if (!h
->def_regular
)
4131 switch (ELF_ST_VISIBILITY (h
->other
))
4134 v
= _("hidden symbol");
4137 v
= _("internal symbol");
4140 v
= _("protected symbol");
4147 (*_bfd_error_handler
)
4148 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4149 input_bfd
, v
, h
->root
.root
.string
);
4150 bfd_set_error (bfd_error_bad_value
);
4153 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4154 && (h
->type
== STT_FUNC
4155 || h
->type
== STT_OBJECT
)
4156 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4158 (*_bfd_error_handler
)
4159 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4161 h
->type
== STT_FUNC
? "function" : "data",
4162 h
->root
.root
.string
);
4163 bfd_set_error (bfd_error_bad_value
);
4168 /* Note that sgot is not involved in this
4169 calculation. We always want the start of .got.plt. If we
4170 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4171 permitted by the ABI, we might have to change this
4173 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4174 + htab
->elf
.sgotplt
->output_offset
;
4178 /* Use global offset table as symbol value. */
4179 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4180 + htab
->elf
.sgotplt
->output_offset
;
4181 unresolved_reloc
= FALSE
;
4185 /* Relocation is to the entry for this symbol in the
4186 procedure linkage table. */
4188 /* Resolve a PLT32 reloc against a local symbol directly,
4189 without using the procedure linkage table. */
4193 if ((h
->plt
.offset
== (bfd_vma
) -1
4194 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4195 || htab
->elf
.splt
== NULL
)
4197 /* We didn't make a PLT entry for this symbol. This
4198 happens when statically linking PIC code, or when
4199 using -Bsymbolic. */
4203 if (h
->plt
.offset
!= (bfd_vma
) -1)
4205 resolved_plt
= htab
->elf
.splt
;
4206 plt_offset
= h
->plt
.offset
;
4210 resolved_plt
= htab
->plt_got
;
4211 plt_offset
= eh
->plt_got
.offset
;
4214 relocation
= (resolved_plt
->output_section
->vma
4215 + resolved_plt
->output_offset
4217 unresolved_reloc
= FALSE
;
4221 /* Set to symbol size. */
4222 relocation
= st_size
;
4227 if ((input_section
->flags
& SEC_ALLOC
) == 0
4231 /* Copy dynamic function pointer relocations. Don't generate
4232 dynamic relocations against resolved undefined weak symbols
4233 in PIE, except for R_386_PC32. */
4234 if ((bfd_link_pic (info
)
4236 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4237 && (!resolved_to_zero
4238 || r_type
== R_386_PC32
))
4239 || h
->root
.type
!= bfd_link_hash_undefweak
))
4240 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4241 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4242 || (ELIMINATE_COPY_RELOCS
4243 && !bfd_link_pic (info
)
4247 || eh
->func_pointer_refcount
> 0
4248 || (h
->root
.type
== bfd_link_hash_undefweak
4249 && !resolved_to_zero
))
4250 && ((h
->def_dynamic
&& !h
->def_regular
)
4251 /* Undefined weak symbol is bound locally when
4253 || h
->root
.type
== bfd_link_hash_undefweak
)))
4255 Elf_Internal_Rela outrel
;
4256 bfd_boolean skip
, relocate
;
4259 /* When generating a shared object, these relocations
4260 are copied into the output file to be resolved at run
4267 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4269 if (outrel
.r_offset
== (bfd_vma
) -1)
4271 else if (outrel
.r_offset
== (bfd_vma
) -2)
4272 skip
= TRUE
, relocate
= TRUE
;
4273 outrel
.r_offset
+= (input_section
->output_section
->vma
4274 + input_section
->output_offset
);
4277 memset (&outrel
, 0, sizeof outrel
);
4280 && (r_type
== R_386_PC32
4281 || !(bfd_link_executable (info
)
4282 || SYMBOLIC_BIND (info
, h
))
4283 || !h
->def_regular
))
4284 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4287 /* This symbol is local, or marked to become local. */
4289 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4292 sreloc
= elf_section_data (input_section
)->sreloc
;
4294 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4296 r
= bfd_reloc_notsupported
;
4297 goto check_relocation_error
;
4300 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4302 /* If this reloc is against an external symbol, we do
4303 not want to fiddle with the addend. Otherwise, we
4304 need to include the symbol value so that it becomes
4305 an addend for the dynamic reloc. */
4312 if (!bfd_link_executable (info
))
4314 Elf_Internal_Rela outrel
;
4317 outrel
.r_offset
= rel
->r_offset
4318 + input_section
->output_section
->vma
4319 + input_section
->output_offset
;
4320 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4321 sreloc
= elf_section_data (input_section
)->sreloc
;
4324 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4329 case R_386_TLS_GOTDESC
:
4330 case R_386_TLS_DESC_CALL
:
4331 case R_386_TLS_IE_32
:
4332 case R_386_TLS_GOTIE
:
4333 tls_type
= GOT_UNKNOWN
;
4334 if (h
== NULL
&& local_got_offsets
)
4335 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4337 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4338 if (tls_type
== GOT_TLS_IE
)
4339 tls_type
= GOT_TLS_IE_NEG
;
4341 if (! elf_i386_tls_transition (info
, input_bfd
,
4342 input_section
, contents
,
4343 symtab_hdr
, sym_hashes
,
4344 &r_type
, tls_type
, rel
,
4345 relend
, h
, r_symndx
))
4348 if (r_type
== R_386_TLS_LE_32
)
4350 BFD_ASSERT (! unresolved_reloc
);
4351 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4356 /* GD->LE transition. */
4357 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4360 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4362 movl %gs:0, %eax; subl $foo@tpoff, %eax
4363 (6 byte form of subl). */
4364 memcpy (contents
+ rel
->r_offset
- 3,
4365 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4366 roff
= rel
->r_offset
+ 5;
4370 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4372 movl %gs:0, %eax; subl $foo@tpoff, %eax
4373 (6 byte form of subl). */
4374 memcpy (contents
+ rel
->r_offset
- 2,
4375 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4376 roff
= rel
->r_offset
+ 6;
4378 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4380 /* Skip R_386_PC32/R_386_PLT32. */
4385 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4387 /* GDesc -> LE transition.
4388 It's originally something like:
4389 leal x@tlsdesc(%ebx), %eax
4393 Registers other than %eax may be set up here. */
4398 roff
= rel
->r_offset
;
4399 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4401 /* Now modify the instruction as appropriate. */
4402 /* aoliva FIXME: remove the above and xor the byte
4404 bfd_put_8 (output_bfd
, val
^ 0x86,
4405 contents
+ roff
- 1);
4406 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4410 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4412 /* GDesc -> LE transition.
4420 roff
= rel
->r_offset
;
4421 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4422 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4425 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4429 /* IE->LE transition:
4430 Originally it can be one of:
4438 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4441 /* movl foo, %eax. */
4442 bfd_put_8 (output_bfd
, 0xb8,
4443 contents
+ rel
->r_offset
- 1);
4449 type
= bfd_get_8 (input_bfd
,
4450 contents
+ rel
->r_offset
- 2);
4455 bfd_put_8 (output_bfd
, 0xc7,
4456 contents
+ rel
->r_offset
- 2);
4457 bfd_put_8 (output_bfd
,
4458 0xc0 | ((val
>> 3) & 7),
4459 contents
+ rel
->r_offset
- 1);
4463 bfd_put_8 (output_bfd
, 0x81,
4464 contents
+ rel
->r_offset
- 2);
4465 bfd_put_8 (output_bfd
,
4466 0xc0 | ((val
>> 3) & 7),
4467 contents
+ rel
->r_offset
- 1);
4474 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4475 contents
+ rel
->r_offset
);
4480 unsigned int val
, type
;
4482 /* {IE_32,GOTIE}->LE transition:
4483 Originally it can be one of:
4484 subl foo(%reg1), %reg2
4485 movl foo(%reg1), %reg2
4486 addl foo(%reg1), %reg2
4489 movl $foo, %reg2 (6 byte form)
4490 addl $foo, %reg2. */
4491 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4492 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4496 bfd_put_8 (output_bfd
, 0xc7,
4497 contents
+ rel
->r_offset
- 2);
4498 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4499 contents
+ rel
->r_offset
- 1);
4501 else if (type
== 0x2b)
4504 bfd_put_8 (output_bfd
, 0x81,
4505 contents
+ rel
->r_offset
- 2);
4506 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4507 contents
+ rel
->r_offset
- 1);
4509 else if (type
== 0x03)
4512 bfd_put_8 (output_bfd
, 0x81,
4513 contents
+ rel
->r_offset
- 2);
4514 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4515 contents
+ rel
->r_offset
- 1);
4519 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4520 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4521 contents
+ rel
->r_offset
);
4523 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4524 contents
+ rel
->r_offset
);
4529 if (htab
->elf
.sgot
== NULL
)
4534 off
= h
->got
.offset
;
4535 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4539 if (local_got_offsets
== NULL
)
4542 off
= local_got_offsets
[r_symndx
];
4543 offplt
= local_tlsdesc_gotents
[r_symndx
];
4550 Elf_Internal_Rela outrel
;
4554 if (htab
->elf
.srelgot
== NULL
)
4557 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4559 if (GOT_TLS_GDESC_P (tls_type
))
4562 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4563 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4564 <= htab
->elf
.sgotplt
->size
);
4565 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4566 + htab
->elf
.sgotplt
->output_offset
4568 + htab
->sgotplt_jump_table_size
);
4569 sreloc
= htab
->elf
.srelplt
;
4570 loc
= sreloc
->contents
;
4571 loc
+= (htab
->next_tls_desc_index
++
4572 * sizeof (Elf32_External_Rel
));
4573 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4574 <= sreloc
->contents
+ sreloc
->size
);
4575 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4578 BFD_ASSERT (! unresolved_reloc
);
4579 bfd_put_32 (output_bfd
,
4580 relocation
- elf_i386_dtpoff_base (info
),
4581 htab
->elf
.sgotplt
->contents
+ offplt
4582 + htab
->sgotplt_jump_table_size
+ 4);
4586 bfd_put_32 (output_bfd
, 0,
4587 htab
->elf
.sgotplt
->contents
+ offplt
4588 + htab
->sgotplt_jump_table_size
+ 4);
4592 sreloc
= htab
->elf
.srelgot
;
4594 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4595 + htab
->elf
.sgot
->output_offset
+ off
);
4597 if (GOT_TLS_GD_P (tls_type
))
4598 dr_type
= R_386_TLS_DTPMOD32
;
4599 else if (GOT_TLS_GDESC_P (tls_type
))
4601 else if (tls_type
== GOT_TLS_IE_POS
)
4602 dr_type
= R_386_TLS_TPOFF
;
4604 dr_type
= R_386_TLS_TPOFF32
;
4606 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4607 bfd_put_32 (output_bfd
,
4608 relocation
- elf_i386_dtpoff_base (info
),
4609 htab
->elf
.sgot
->contents
+ off
);
4610 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4611 bfd_put_32 (output_bfd
,
4612 elf_i386_dtpoff_base (info
) - relocation
,
4613 htab
->elf
.sgot
->contents
+ off
);
4614 else if (dr_type
!= R_386_TLS_DESC
)
4615 bfd_put_32 (output_bfd
, 0,
4616 htab
->elf
.sgot
->contents
+ off
);
4617 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4619 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4621 if (GOT_TLS_GD_P (tls_type
))
4625 BFD_ASSERT (! unresolved_reloc
);
4626 bfd_put_32 (output_bfd
,
4627 relocation
- elf_i386_dtpoff_base (info
),
4628 htab
->elf
.sgot
->contents
+ off
+ 4);
4632 bfd_put_32 (output_bfd
, 0,
4633 htab
->elf
.sgot
->contents
+ off
+ 4);
4634 outrel
.r_info
= ELF32_R_INFO (indx
,
4635 R_386_TLS_DTPOFF32
);
4636 outrel
.r_offset
+= 4;
4637 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4640 else if (tls_type
== GOT_TLS_IE_BOTH
)
4642 bfd_put_32 (output_bfd
,
4644 ? relocation
- elf_i386_dtpoff_base (info
)
4646 htab
->elf
.sgot
->contents
+ off
+ 4);
4647 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4648 outrel
.r_offset
+= 4;
4649 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4656 local_got_offsets
[r_symndx
] |= 1;
4659 if (off
>= (bfd_vma
) -2
4660 && ! GOT_TLS_GDESC_P (tls_type
))
4662 if (r_type
== R_386_TLS_GOTDESC
4663 || r_type
== R_386_TLS_DESC_CALL
)
4665 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4666 unresolved_reloc
= FALSE
;
4668 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4670 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4671 + htab
->elf
.sgotplt
->output_offset
;
4672 relocation
= htab
->elf
.sgot
->output_section
->vma
4673 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4674 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4675 && tls_type
== GOT_TLS_IE_BOTH
)
4677 if (r_type
== R_386_TLS_IE
)
4678 relocation
+= g_o_t
;
4679 unresolved_reloc
= FALSE
;
4681 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4683 unsigned int val
, type
;
4686 /* GD->IE transition. */
4687 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4688 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4691 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4693 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4695 roff
= rel
->r_offset
- 3;
4699 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4701 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4702 roff
= rel
->r_offset
- 2;
4704 memcpy (contents
+ roff
,
4705 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4706 contents
[roff
+ 7] = 0x80 | (val
& 7);
4707 /* If foo is used only with foo@gotntpoff(%reg) and
4708 foo@indntpoff, but not with foo@gottpoff(%reg), change
4709 subl $foo@gottpoff(%reg), %eax
4711 addl $foo@gotntpoff(%reg), %eax. */
4712 if (tls_type
== GOT_TLS_IE_POS
)
4713 contents
[roff
+ 6] = 0x03;
4714 bfd_put_32 (output_bfd
,
4715 htab
->elf
.sgot
->output_section
->vma
4716 + htab
->elf
.sgot
->output_offset
+ off
4717 - htab
->elf
.sgotplt
->output_section
->vma
4718 - htab
->elf
.sgotplt
->output_offset
,
4719 contents
+ roff
+ 8);
4720 /* Skip R_386_PLT32. */
4725 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4727 /* GDesc -> IE transition.
4728 It's originally something like:
4729 leal x@tlsdesc(%ebx), %eax
4732 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4734 movl x@gottpoff(%ebx), %eax # before negl %eax
4736 Registers other than %eax may be set up here. */
4740 /* First, make sure it's a leal adding ebx to a 32-bit
4741 offset into any register, although it's probably
4742 almost always going to be eax. */
4743 roff
= rel
->r_offset
;
4745 /* Now modify the instruction as appropriate. */
4746 /* To turn a leal into a movl in the form we use it, it
4747 suffices to change the first byte from 0x8d to 0x8b.
4748 aoliva FIXME: should we decide to keep the leal, all
4749 we have to do is remove the statement below, and
4750 adjust the relaxation of R_386_TLS_DESC_CALL. */
4751 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4753 if (tls_type
== GOT_TLS_IE_BOTH
)
4756 bfd_put_32 (output_bfd
,
4757 htab
->elf
.sgot
->output_section
->vma
4758 + htab
->elf
.sgot
->output_offset
+ off
4759 - htab
->elf
.sgotplt
->output_section
->vma
4760 - htab
->elf
.sgotplt
->output_offset
,
4764 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4766 /* GDesc -> IE transition.
4774 depending on how we transformed the TLS_GOTDESC above.
4779 roff
= rel
->r_offset
;
4781 /* Now modify the instruction as appropriate. */
4782 if (tls_type
!= GOT_TLS_IE_NEG
)
4785 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4786 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4791 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
4792 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
4802 if (! elf_i386_tls_transition (info
, input_bfd
,
4803 input_section
, contents
,
4804 symtab_hdr
, sym_hashes
,
4805 &r_type
, GOT_UNKNOWN
, rel
,
4806 relend
, h
, r_symndx
))
4809 if (r_type
!= R_386_TLS_LDM
)
4811 /* LD->LE transition:
4812 leal foo(%reg), %eax; call ___tls_get_addr.
4814 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4815 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
4816 memcpy (contents
+ rel
->r_offset
- 2,
4817 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4818 /* Skip R_386_PC32/R_386_PLT32. */
4824 if (htab
->elf
.sgot
== NULL
)
4827 off
= htab
->tls_ldm_got
.offset
;
4832 Elf_Internal_Rela outrel
;
4834 if (htab
->elf
.srelgot
== NULL
)
4837 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4838 + htab
->elf
.sgot
->output_offset
+ off
);
4840 bfd_put_32 (output_bfd
, 0,
4841 htab
->elf
.sgot
->contents
+ off
);
4842 bfd_put_32 (output_bfd
, 0,
4843 htab
->elf
.sgot
->contents
+ off
+ 4);
4844 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
4845 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
4846 htab
->tls_ldm_got
.offset
|= 1;
4848 relocation
= htab
->elf
.sgot
->output_section
->vma
4849 + htab
->elf
.sgot
->output_offset
+ off
4850 - htab
->elf
.sgotplt
->output_section
->vma
4851 - htab
->elf
.sgotplt
->output_offset
;
4852 unresolved_reloc
= FALSE
;
4855 case R_386_TLS_LDO_32
:
4856 if (!bfd_link_executable (info
)
4857 || (input_section
->flags
& SEC_CODE
) == 0)
4858 relocation
-= elf_i386_dtpoff_base (info
);
4860 /* When converting LDO to LE, we must negate. */
4861 relocation
= -elf_i386_tpoff (info
, relocation
);
4864 case R_386_TLS_LE_32
:
4866 if (!bfd_link_executable (info
))
4868 Elf_Internal_Rela outrel
;
4871 outrel
.r_offset
= rel
->r_offset
4872 + input_section
->output_section
->vma
4873 + input_section
->output_offset
;
4874 if (h
!= NULL
&& h
->dynindx
!= -1)
4878 if (r_type
== R_386_TLS_LE_32
)
4879 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
4881 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4882 sreloc
= elf_section_data (input_section
)->sreloc
;
4885 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4888 else if (r_type
== R_386_TLS_LE_32
)
4889 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
4891 relocation
-= elf_i386_dtpoff_base (info
);
4893 else if (r_type
== R_386_TLS_LE_32
)
4894 relocation
= elf_i386_tpoff (info
, relocation
);
4896 relocation
= -elf_i386_tpoff (info
, relocation
);
4903 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4904 because such sections are not SEC_ALLOC and thus ld.so will
4905 not process them. */
4906 if (unresolved_reloc
4907 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4909 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4910 rel
->r_offset
) != (bfd_vma
) -1)
4912 (*_bfd_error_handler
)
4913 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4916 (long) rel
->r_offset
,
4918 h
->root
.root
.string
);
4923 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4924 contents
, rel
->r_offset
,
4927 check_relocation_error
:
4928 if (r
!= bfd_reloc_ok
)
4933 name
= h
->root
.root
.string
;
4936 name
= bfd_elf_string_from_elf_section (input_bfd
,
4937 symtab_hdr
->sh_link
,
4942 name
= bfd_section_name (input_bfd
, sec
);
4945 if (r
== bfd_reloc_overflow
)
4947 if (! ((*info
->callbacks
->reloc_overflow
)
4948 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4949 (bfd_vma
) 0, input_bfd
, input_section
,
4955 (*_bfd_error_handler
)
4956 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4957 input_bfd
, input_section
,
4958 (long) rel
->r_offset
, name
, (int) r
);
4969 Elf_Internal_Shdr
*rel_hdr
;
4970 size_t deleted
= rel
- wrel
;
4972 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4973 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4974 if (rel_hdr
->sh_size
== 0)
4976 /* It is too late to remove an empty reloc section. Leave
4978 ??? What is wrong with an empty section??? */
4979 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4982 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
4983 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4984 input_section
->reloc_count
-= deleted
;
4990 /* Finish up dynamic symbol handling. We set the contents of various
4991 dynamic sections here. */
4994 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
4995 struct bfd_link_info
*info
,
4996 struct elf_link_hash_entry
*h
,
4997 Elf_Internal_Sym
*sym
)
4999 struct elf_i386_link_hash_table
*htab
;
5000 unsigned plt_entry_size
;
5001 const struct elf_i386_backend_data
*abed
;
5002 struct elf_i386_link_hash_entry
*eh
;
5003 bfd_boolean local_undefweak
;
5005 htab
= elf_i386_hash_table (info
);
5009 abed
= get_elf_i386_backend_data (output_bfd
);
5010 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5012 eh
= (struct elf_i386_link_hash_entry
*) h
;
5014 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5015 resolved undefined weak symbols in executable so that their
5016 references have value 0 at run-time. */
5017 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5019 if (h
->plt
.offset
!= (bfd_vma
) -1)
5023 Elf_Internal_Rela rel
;
5025 asection
*plt
, *gotplt
, *relplt
;
5027 /* When building a static executable, use .iplt, .igot.plt and
5028 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5029 if (htab
->elf
.splt
!= NULL
)
5031 plt
= htab
->elf
.splt
;
5032 gotplt
= htab
->elf
.sgotplt
;
5033 relplt
= htab
->elf
.srelplt
;
5037 plt
= htab
->elf
.iplt
;
5038 gotplt
= htab
->elf
.igotplt
;
5039 relplt
= htab
->elf
.irelplt
;
5042 /* This symbol has an entry in the procedure linkage table. Set
5045 if ((h
->dynindx
== -1
5047 && !((h
->forced_local
|| bfd_link_executable (info
))
5049 && h
->type
== STT_GNU_IFUNC
))
5055 /* Get the index in the procedure linkage table which
5056 corresponds to this symbol. This is the index of this symbol
5057 in all the symbols for which we are making plt entries. The
5058 first entry in the procedure linkage table is reserved.
5060 Get the offset into the .got table of the entry that
5061 corresponds to this function. Each .got entry is 4 bytes.
5062 The first three are reserved.
5064 For static executables, we don't reserve anything. */
5066 if (plt
== htab
->elf
.splt
)
5068 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5069 got_offset
= (got_offset
+ 3) * 4;
5073 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5074 got_offset
= got_offset
* 4;
5077 /* Fill in the entry in the procedure linkage table. */
5078 if (! bfd_link_pic (info
))
5080 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5081 abed
->plt
->plt_entry_size
);
5082 bfd_put_32 (output_bfd
,
5083 (gotplt
->output_section
->vma
5084 + gotplt
->output_offset
5086 plt
->contents
+ h
->plt
.offset
5087 + abed
->plt
->plt_got_offset
);
5089 if (abed
->is_vxworks
)
5091 int s
, k
, reloc_index
;
5093 /* Create the R_386_32 relocation referencing the GOT
5094 for this PLT entry. */
5096 /* S: Current slot number (zero-based). */
5097 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5098 / abed
->plt
->plt_entry_size
);
5099 /* K: Number of relocations for PLTResolve. */
5100 if (bfd_link_pic (info
))
5101 k
= PLTRESOLVE_RELOCS_SHLIB
;
5103 k
= PLTRESOLVE_RELOCS
;
5104 /* Skip the PLTresolve relocations, and the relocations for
5105 the other PLT slots. */
5106 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5107 loc
= (htab
->srelplt2
->contents
+ reloc_index
5108 * sizeof (Elf32_External_Rel
));
5110 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5111 + htab
->elf
.splt
->output_offset
5112 + h
->plt
.offset
+ 2),
5113 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5114 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5116 /* Create the R_386_32 relocation referencing the beginning of
5117 the PLT for this GOT entry. */
5118 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5119 + htab
->elf
.sgotplt
->output_offset
5121 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5122 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5123 loc
+ sizeof (Elf32_External_Rel
));
5128 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5129 abed
->plt
->plt_entry_size
);
5130 bfd_put_32 (output_bfd
, got_offset
,
5131 plt
->contents
+ h
->plt
.offset
5132 + abed
->plt
->plt_got_offset
);
5135 /* Fill in the entry in the global offset table. Leave the entry
5136 as zero for undefined weak symbol in PIE. No PLT relocation
5137 against undefined weak symbol in PIE. */
5138 if (!local_undefweak
)
5140 bfd_put_32 (output_bfd
,
5141 (plt
->output_section
->vma
5142 + plt
->output_offset
5144 + abed
->plt
->plt_lazy_offset
),
5145 gotplt
->contents
+ got_offset
);
5147 /* Fill in the entry in the .rel.plt section. */
5148 rel
.r_offset
= (gotplt
->output_section
->vma
5149 + gotplt
->output_offset
5151 if (h
->dynindx
== -1
5152 || ((bfd_link_executable (info
)
5153 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5155 && h
->type
== STT_GNU_IFUNC
))
5157 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5158 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5159 in the .got.plt section. */
5160 bfd_put_32 (output_bfd
,
5161 (h
->root
.u
.def
.value
5162 + h
->root
.u
.def
.section
->output_section
->vma
5163 + h
->root
.u
.def
.section
->output_offset
),
5164 gotplt
->contents
+ got_offset
);
5165 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5166 /* R_386_IRELATIVE comes last. */
5167 plt_index
= htab
->next_irelative_index
--;
5171 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5172 plt_index
= htab
->next_jump_slot_index
++;
5175 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5176 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5178 /* Don't fill PLT entry for static executables. */
5179 if (plt
== htab
->elf
.splt
)
5181 bfd_put_32 (output_bfd
,
5182 plt_index
* sizeof (Elf32_External_Rel
),
5183 plt
->contents
+ h
->plt
.offset
5184 + abed
->plt
->plt_reloc_offset
);
5185 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5186 + abed
->plt
->plt_plt_offset
+ 4),
5187 plt
->contents
+ h
->plt
.offset
5188 + abed
->plt
->plt_plt_offset
);
5192 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5194 bfd_vma got_offset
, plt_offset
;
5195 asection
*plt
, *got
, *gotplt
;
5196 const bfd_byte
*got_plt_entry
;
5198 /* Offset of displacement of the indirect jump. */
5199 bfd_vma plt_got_offset
= 2;
5201 /* Set the entry in the GOT procedure linkage table. */
5202 plt
= htab
->plt_got
;
5203 got
= htab
->elf
.sgot
;
5204 gotplt
= htab
->elf
.sgotplt
;
5205 got_offset
= h
->got
.offset
;
5207 if (got_offset
== (bfd_vma
) -1
5213 /* Fill in the entry in the GOT procedure linkage table. */
5214 if (! bfd_link_pic (info
))
5216 got_plt_entry
= elf_i386_got_plt_entry
;
5217 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5221 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5222 got_offset
+= (got
->output_section
->vma
5223 + got
->output_offset
5224 - gotplt
->output_section
->vma
5225 - gotplt
->output_offset
);
5228 plt_offset
= eh
->plt_got
.offset
;
5229 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5230 sizeof (elf_i386_got_plt_entry
));
5231 bfd_put_32 (output_bfd
, got_offset
,
5232 plt
->contents
+ plt_offset
+ plt_got_offset
);
5235 if (!local_undefweak
5237 && (h
->plt
.offset
!= (bfd_vma
) -1
5238 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5240 /* Mark the symbol as undefined, rather than as defined in
5241 the .plt section. Leave the value if there were any
5242 relocations where pointer equality matters (this is a clue
5243 for the dynamic linker, to make function pointer
5244 comparisons work between an application and shared
5245 library), otherwise set it to zero. If a function is only
5246 called from a binary, there is no need to slow down
5247 shared libraries because of that. */
5248 sym
->st_shndx
= SHN_UNDEF
;
5249 if (!h
->pointer_equality_needed
)
5253 /* Don't generate dynamic GOT relocation against undefined weak
5254 symbol in executable. */
5255 if (h
->got
.offset
!= (bfd_vma
) -1
5256 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5257 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5258 && !local_undefweak
)
5260 Elf_Internal_Rela rel
;
5262 /* This symbol has an entry in the global offset table. Set it
5265 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5268 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5269 + htab
->elf
.sgot
->output_offset
5270 + (h
->got
.offset
& ~(bfd_vma
) 1));
5272 /* If this is a static link, or it is a -Bsymbolic link and the
5273 symbol is defined locally or was forced to be local because
5274 of a version file, we just want to emit a RELATIVE reloc.
5275 The entry in the global offset table will already have been
5276 initialized in the relocate_section function. */
5278 && h
->type
== STT_GNU_IFUNC
)
5280 if (bfd_link_pic (info
))
5282 /* Generate R_386_GLOB_DAT. */
5289 if (!h
->pointer_equality_needed
)
5292 /* For non-shared object, we can't use .got.plt, which
5293 contains the real function addres if we need pointer
5294 equality. We load the GOT entry with the PLT entry. */
5295 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5296 bfd_put_32 (output_bfd
,
5297 (plt
->output_section
->vma
5298 + plt
->output_offset
+ h
->plt
.offset
),
5299 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5303 else if (bfd_link_pic (info
)
5304 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5306 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5307 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5311 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5313 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5314 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5315 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5318 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &rel
);
5323 Elf_Internal_Rela rel
;
5325 /* This symbol needs a copy reloc. Set it up. */
5327 if (h
->dynindx
== -1
5328 || (h
->root
.type
!= bfd_link_hash_defined
5329 && h
->root
.type
!= bfd_link_hash_defweak
)
5330 || htab
->srelbss
== NULL
)
5333 rel
.r_offset
= (h
->root
.u
.def
.value
5334 + h
->root
.u
.def
.section
->output_section
->vma
5335 + h
->root
.u
.def
.section
->output_offset
);
5336 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5337 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5343 /* Finish up local dynamic symbol handling. We set the contents of
5344 various dynamic sections here. */
5347 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5349 struct elf_link_hash_entry
*h
5350 = (struct elf_link_hash_entry
*) *slot
;
5351 struct bfd_link_info
*info
5352 = (struct bfd_link_info
*) inf
;
5354 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5358 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5359 here since undefined weak symbol may not be dynamic and may not be
5360 called for elf_i386_finish_dynamic_symbol. */
5363 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5366 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5367 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5369 if (h
->root
.type
!= bfd_link_hash_undefweak
5370 || h
->dynindx
!= -1)
5373 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5377 /* Used to decide how to sort relocs in an optimal manner for the
5378 dynamic linker, before writing them out. */
5380 static enum elf_reloc_type_class
5381 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5382 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5383 const Elf_Internal_Rela
*rela
)
5385 bfd
*abfd
= info
->output_bfd
;
5386 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5387 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5389 if (htab
->dynsym
!= NULL
5390 && htab
->dynsym
->contents
!= NULL
)
5392 /* Check relocation against STT_GNU_IFUNC symbol if there are
5394 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5395 Elf_Internal_Sym sym
;
5396 if (!bed
->s
->swap_symbol_in (abfd
,
5397 (htab
->dynsym
->contents
5398 + r_symndx
* sizeof (Elf32_External_Sym
)),
5402 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5403 return reloc_class_ifunc
;
5406 switch (ELF32_R_TYPE (rela
->r_info
))
5408 case R_386_RELATIVE
:
5409 return reloc_class_relative
;
5410 case R_386_JUMP_SLOT
:
5411 return reloc_class_plt
;
5413 return reloc_class_copy
;
5415 return reloc_class_normal
;
5419 /* Finish up the dynamic sections. */
5422 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5423 struct bfd_link_info
*info
)
5425 struct elf_i386_link_hash_table
*htab
;
5428 const struct elf_i386_backend_data
*abed
;
5430 htab
= elf_i386_hash_table (info
);
5434 dynobj
= htab
->elf
.dynobj
;
5435 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5436 abed
= get_elf_i386_backend_data (output_bfd
);
5438 if (htab
->elf
.dynamic_sections_created
)
5440 Elf32_External_Dyn
*dyncon
, *dynconend
;
5442 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5445 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5446 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5447 for (; dyncon
< dynconend
; dyncon
++)
5449 Elf_Internal_Dyn dyn
;
5452 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5457 if (abed
->is_vxworks
5458 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5463 s
= htab
->elf
.sgotplt
;
5464 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5468 s
= htab
->elf
.srelplt
;
5469 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5473 s
= htab
->elf
.srelplt
;
5474 dyn
.d_un
.d_val
= s
->size
;
5478 /* My reading of the SVR4 ABI indicates that the
5479 procedure linkage table relocs (DT_JMPREL) should be
5480 included in the overall relocs (DT_REL). This is
5481 what Solaris does. However, UnixWare can not handle
5482 that case. Therefore, we override the DT_RELSZ entry
5483 here to make it not include the JMPREL relocs. */
5484 s
= htab
->elf
.srelplt
;
5487 dyn
.d_un
.d_val
-= s
->size
;
5491 /* We may not be using the standard ELF linker script.
5492 If .rel.plt is the first .rel section, we adjust
5493 DT_REL to not include it. */
5494 s
= htab
->elf
.srelplt
;
5497 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5499 dyn
.d_un
.d_ptr
+= s
->size
;
5503 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5506 /* Fill in the first entry in the procedure linkage table. */
5507 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5509 if (bfd_link_pic (info
))
5511 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5512 abed
->plt
->plt0_entry_size
);
5513 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5514 abed
->plt0_pad_byte
,
5515 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5519 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5520 abed
->plt
->plt0_entry_size
);
5521 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5522 abed
->plt0_pad_byte
,
5523 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5524 bfd_put_32 (output_bfd
,
5525 (htab
->elf
.sgotplt
->output_section
->vma
5526 + htab
->elf
.sgotplt
->output_offset
5528 htab
->elf
.splt
->contents
5529 + abed
->plt
->plt0_got1_offset
);
5530 bfd_put_32 (output_bfd
,
5531 (htab
->elf
.sgotplt
->output_section
->vma
5532 + htab
->elf
.sgotplt
->output_offset
5534 htab
->elf
.splt
->contents
5535 + abed
->plt
->plt0_got2_offset
);
5537 if (abed
->is_vxworks
)
5539 Elf_Internal_Rela rel
;
5541 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5542 On IA32 we use REL relocations so the addend goes in
5543 the PLT directly. */
5544 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5545 + htab
->elf
.splt
->output_offset
5546 + abed
->plt
->plt0_got1_offset
);
5547 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5548 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5549 htab
->srelplt2
->contents
);
5550 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5551 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5552 + htab
->elf
.splt
->output_offset
5553 + abed
->plt
->plt0_got2_offset
);
5554 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5555 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5556 htab
->srelplt2
->contents
+
5557 sizeof (Elf32_External_Rel
));
5561 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5562 really seem like the right value. */
5563 elf_section_data (htab
->elf
.splt
->output_section
)
5564 ->this_hdr
.sh_entsize
= 4;
5566 /* Correct the .rel.plt.unloaded relocations. */
5567 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5569 int num_plts
= (htab
->elf
.splt
->size
5570 / abed
->plt
->plt_entry_size
) - 1;
5573 p
= htab
->srelplt2
->contents
;
5574 if (bfd_link_pic (info
))
5575 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5577 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5579 for (; num_plts
; num_plts
--)
5581 Elf_Internal_Rela rel
;
5582 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5583 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5584 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5585 p
+= sizeof (Elf32_External_Rel
);
5587 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5588 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5589 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5590 p
+= sizeof (Elf32_External_Rel
);
5596 if (htab
->elf
.sgotplt
)
5598 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5600 (*_bfd_error_handler
)
5601 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5605 /* Fill in the first three entries in the global offset table. */
5606 if (htab
->elf
.sgotplt
->size
> 0)
5608 bfd_put_32 (output_bfd
,
5610 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5611 htab
->elf
.sgotplt
->contents
);
5612 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5613 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5616 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5619 /* Adjust .eh_frame for .plt section. */
5620 if (htab
->plt_eh_frame
!= NULL
5621 && htab
->plt_eh_frame
->contents
!= NULL
)
5623 if (htab
->elf
.splt
!= NULL
5624 && htab
->elf
.splt
->size
!= 0
5625 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5626 && htab
->elf
.splt
->output_section
!= NULL
5627 && htab
->plt_eh_frame
->output_section
!= NULL
)
5629 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5630 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5631 + htab
->plt_eh_frame
->output_offset
5632 + PLT_FDE_START_OFFSET
;
5633 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5634 htab
->plt_eh_frame
->contents
5635 + PLT_FDE_START_OFFSET
);
5637 if (htab
->plt_eh_frame
->sec_info_type
5638 == SEC_INFO_TYPE_EH_FRAME
)
5640 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5642 htab
->plt_eh_frame
->contents
))
5647 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5648 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5650 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5651 htab_traverse (htab
->loc_hash_table
,
5652 elf_i386_finish_local_dynamic_symbol
,
5655 /* Fill PLT entries for undefined weak symbols in PIE. */
5656 if (bfd_link_pie (info
))
5657 bfd_hash_traverse (&info
->hash
->table
,
5658 elf_i386_pie_finish_undefweak_symbol
,
5664 /* Return an array of PLT entry symbol values. */
5667 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5670 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5673 bfd_vma
*plt_sym_val
;
5675 bfd_byte
*plt_contents
;
5676 const struct elf_i386_backend_data
*bed
5677 = get_elf_i386_backend_data (abfd
);
5678 Elf_Internal_Shdr
*hdr
;
5680 /* Get the .plt section contents. */
5681 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5682 if (plt_contents
== NULL
)
5684 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5685 plt_contents
, 0, plt
->size
))
5688 free (plt_contents
);
5692 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5693 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5696 hdr
= &elf_section_data (relplt
)->this_hdr
;
5697 count
= relplt
->size
/ hdr
->sh_entsize
;
5699 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5700 if (plt_sym_val
== NULL
)
5703 for (i
= 0; i
< count
; i
++)
5704 plt_sym_val
[i
] = -1;
5706 plt_offset
= bed
->plt
->plt_entry_size
;
5707 p
= relplt
->relocation
;
5708 for (i
= 0; i
< count
; i
++, p
++)
5712 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5713 if (p
->howto
== NULL
)
5716 if (p
->howto
->type
!= R_386_JUMP_SLOT
5717 && p
->howto
->type
!= R_386_IRELATIVE
)
5720 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5721 + bed
->plt
->plt_reloc_offset
));
5722 reloc_index
/= sizeof (Elf32_External_Rel
);
5723 if (reloc_index
< count
)
5724 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5726 plt_offset
+= bed
->plt
->plt_entry_size
;
5728 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5730 if (plt_offset
>= plt
->size
)
5734 free (plt_contents
);
5739 /* Similar to _bfd_elf_get_synthetic_symtab. */
5742 elf_i386_get_synthetic_symtab (bfd
*abfd
,
5749 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
5750 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5751 dynsymcount
, dynsyms
, ret
,
5753 elf_i386_get_plt_sym_val
);
5756 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5759 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
5761 if (h
->plt
.offset
!= (bfd_vma
) -1
5763 && !h
->pointer_equality_needed
)
5766 return _bfd_elf_hash_symbol (h
);
5769 /* Hook called by the linker routine which adds symbols from an object
5773 elf_i386_add_symbol_hook (bfd
* abfd
,
5774 struct bfd_link_info
* info
,
5775 Elf_Internal_Sym
* sym
,
5776 const char ** namep ATTRIBUTE_UNUSED
,
5777 flagword
* flagsp ATTRIBUTE_UNUSED
,
5778 asection
** secp ATTRIBUTE_UNUSED
,
5779 bfd_vma
* valp ATTRIBUTE_UNUSED
)
5781 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
5782 && (abfd
->flags
& DYNAMIC
) == 0
5783 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5784 elf_tdata (info
->output_bfd
)->has_gnu_symbols
5785 |= elf_gnu_symbol_unique
;
5790 #define TARGET_LITTLE_SYM i386_elf32_vec
5791 #define TARGET_LITTLE_NAME "elf32-i386"
5792 #define ELF_ARCH bfd_arch_i386
5793 #define ELF_TARGET_ID I386_ELF_DATA
5794 #define ELF_MACHINE_CODE EM_386
5795 #define ELF_MAXPAGESIZE 0x1000
5797 #define elf_backend_can_gc_sections 1
5798 #define elf_backend_can_refcount 1
5799 #define elf_backend_want_got_plt 1
5800 #define elf_backend_plt_readonly 1
5801 #define elf_backend_want_plt_sym 0
5802 #define elf_backend_got_header_size 12
5803 #define elf_backend_plt_alignment 4
5804 #define elf_backend_extern_protected_data 1
5806 /* Support RELA for objdump of prelink objects. */
5807 #define elf_info_to_howto elf_i386_info_to_howto_rel
5808 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5810 #define bfd_elf32_mkobject elf_i386_mkobject
5812 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5813 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5814 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5815 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5816 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5818 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5819 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5820 #define elf_backend_check_relocs elf_i386_check_relocs
5821 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5822 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5823 #define elf_backend_fake_sections elf_i386_fake_sections
5824 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5825 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5826 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5827 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5828 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5829 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5830 #define elf_backend_relocate_section elf_i386_relocate_section
5831 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5832 #define elf_backend_always_size_sections elf_i386_always_size_sections
5833 #define elf_backend_omit_section_dynsym \
5834 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5835 #define elf_backend_hash_symbol elf_i386_hash_symbol
5836 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5837 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5839 #include "elf32-target.h"
5841 /* FreeBSD support. */
5843 #undef TARGET_LITTLE_SYM
5844 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5845 #undef TARGET_LITTLE_NAME
5846 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5848 #define ELF_OSABI ELFOSABI_FREEBSD
5850 /* The kernel recognizes executables as valid only if they carry a
5851 "FreeBSD" label in the ELF header. So we put this label on all
5852 executables and (for simplicity) also all other object files. */
5855 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
5857 _bfd_elf_post_process_headers (abfd
, info
);
5859 #ifdef OLD_FREEBSD_ABI_LABEL
5861 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5862 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5863 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5868 #undef elf_backend_post_process_headers
5869 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5871 #define elf32_bed elf32_i386_fbsd_bed
5873 #undef elf_backend_add_symbol_hook
5875 #include "elf32-target.h"
5879 #undef TARGET_LITTLE_SYM
5880 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5881 #undef TARGET_LITTLE_NAME
5882 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5884 #undef elf_backend_post_process_headers
5886 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5887 objects won't be recognized. */
5891 #define elf32_bed elf32_i386_sol2_bed
5893 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5895 #undef elf_backend_static_tls_alignment
5896 #define elf_backend_static_tls_alignment 8
5898 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5900 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5902 #undef elf_backend_want_plt_sym
5903 #define elf_backend_want_plt_sym 1
5905 #undef elf_backend_strtab_flags
5906 #define elf_backend_strtab_flags SHF_STRINGS
5909 elf32_i386_set_special_info_link (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.
5917 Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5918 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5920 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5922 The following values should be set:
5925 -----------------------------------------------------------------------------
5926 SHT_SUNW_ancillary The section header index of 0
5927 [0x6fffffee] the associated string table.
5929 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5930 [0x6ffffff0] the associated symbol table. section header index of
5932 SHT_SUNW_capchain table,
5935 SHT_SUNW_symsort The section header index of 0
5936 [0x6ffffff1] the associated symbol table.
5938 SHT_SUNW_tlssort The section header index of 0
5939 [0x6ffffff2] the associated symbol table.
5941 SHT_SUNW_LDYNSYM The section header index of One greater than the
5942 [0x6ffffff3] the associated string table. symbol table index of the
5943 This index is the same string last local symbol,
5944 table used by the SHT_DYNSYM STB_LOCAL. Since
5945 section. SHT_SUNW_LDYNSYM only
5946 contains local symbols,
5947 sh_info is equivalent to
5948 the number of symbols in
5951 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5952 [0x6ffffff5] the section header index of to named strings, the
5953 the associated section header index of
5954 SHT_SUNW_capinfo table, the associated string
5955 otherwise 0. table, otherwise 0.
5957 SHT_SUNW_move The section header index of 0
5958 [0x6ffffffa] the associated symbol table.
5963 SHT_SUNW_syminfo The section header index of The section header index
5964 [0x6ffffffc] the associated symbol table. of the associated
5967 SHT_SUNW_verdef The section header index of The number of version
5968 [0x6ffffffd] the associated string table. definitions within the
5971 SHT_SUNW_verneed The section header index of The number of version
5972 [0x6ffffffe] the associated string table. dependencies within the
5975 SHT_SUNW_versym The section header index of 0
5976 [0x6fffffff] the associated symbol table. */
5980 #undef elf_backend_set_special_section_info_and_link
5981 #define elf_backend_set_special_section_info_and_link elf32_i386_set_special_info_link
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_set_special_section_info_and_link
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"