1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
32 #include "opcode/i386.h"
34 /* 386 uses REL relocations instead of RELA. */
39 static reloc_howto_type elf_howto_table
[]=
41 HOWTO(R_386_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
42 bfd_elf_generic_reloc
, "R_386_NONE",
43 TRUE
, 0x00000000, 0x00000000, FALSE
),
44 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
45 bfd_elf_generic_reloc
, "R_386_32",
46 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
47 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
48 bfd_elf_generic_reloc
, "R_386_PC32",
49 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
50 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
51 bfd_elf_generic_reloc
, "R_386_GOT32",
52 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
53 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_386_PLT32",
55 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
56 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
57 bfd_elf_generic_reloc
, "R_386_COPY",
58 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
59 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
60 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
61 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
62 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
64 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
65 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_386_RELATIVE",
67 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
68 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
, "R_386_GOTOFF",
70 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
71 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
72 bfd_elf_generic_reloc
, "R_386_GOTPC",
73 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
85 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
86 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_386_TLS_IE",
88 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
89 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
91 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
92 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_386_TLS_LE",
94 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
95 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_386_TLS_GD",
97 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
98 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
100 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
101 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_386_16",
103 TRUE
, 0xffff, 0xffff, FALSE
),
104 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_386_PC16",
106 TRUE
, 0xffff, 0xffff, TRUE
),
107 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_386_8",
109 TRUE
, 0xff, 0xff, FALSE
),
110 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_386_PC8",
112 TRUE
, 0xff, 0xff, TRUE
),
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
118 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
119 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
120 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
122 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
123 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
125 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
126 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
128 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
129 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
131 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
132 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
133 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
134 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
135 HOWTO(R_386_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
136 bfd_elf_generic_reloc
, "R_386_SIZE32",
137 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
138 HOWTO(R_386_TLS_GOTDESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
139 bfd_elf_generic_reloc
, "R_386_TLS_GOTDESC",
140 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
141 HOWTO(R_386_TLS_DESC_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
142 bfd_elf_generic_reloc
, "R_386_TLS_DESC_CALL",
144 HOWTO(R_386_TLS_DESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
145 bfd_elf_generic_reloc
, "R_386_TLS_DESC",
146 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
147 HOWTO(R_386_IRELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
148 bfd_elf_generic_reloc
, "R_386_IRELATIVE",
149 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
150 HOWTO(R_386_GOT32X
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
151 bfd_elf_generic_reloc
, "R_386_GOT32X",
152 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
155 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
156 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
158 /* GNU extension to record C++ vtable hierarchy. */
159 HOWTO (R_386_GNU_VTINHERIT
, /* type */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
163 FALSE
, /* pc_relative */
165 complain_overflow_dont
, /* complain_on_overflow */
166 NULL
, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
168 FALSE
, /* partial_inplace */
171 FALSE
), /* pcrel_offset */
173 /* GNU extension to record C++ vtable member usage. */
174 HOWTO (R_386_GNU_VTENTRY
, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE
, /* pc_relative */
180 complain_overflow_dont
, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
183 FALSE
, /* partial_inplace */
186 FALSE
) /* pcrel_offset */
188 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
192 #ifdef DEBUG_GEN_RELOC
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
199 static reloc_howto_type
*
200 elf_i386_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
201 bfd_reloc_code_real_type code
)
206 TRACE ("BFD_RELOC_NONE");
207 return &elf_howto_table
[R_386_NONE
];
210 TRACE ("BFD_RELOC_32");
211 return &elf_howto_table
[R_386_32
];
214 TRACE ("BFD_RELOC_CTOR");
215 return &elf_howto_table
[R_386_32
];
217 case BFD_RELOC_32_PCREL
:
218 TRACE ("BFD_RELOC_PC32");
219 return &elf_howto_table
[R_386_PC32
];
221 case BFD_RELOC_386_GOT32
:
222 TRACE ("BFD_RELOC_386_GOT32");
223 return &elf_howto_table
[R_386_GOT32
];
225 case BFD_RELOC_386_PLT32
:
226 TRACE ("BFD_RELOC_386_PLT32");
227 return &elf_howto_table
[R_386_PLT32
];
229 case BFD_RELOC_386_COPY
:
230 TRACE ("BFD_RELOC_386_COPY");
231 return &elf_howto_table
[R_386_COPY
];
233 case BFD_RELOC_386_GLOB_DAT
:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
235 return &elf_howto_table
[R_386_GLOB_DAT
];
237 case BFD_RELOC_386_JUMP_SLOT
:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
239 return &elf_howto_table
[R_386_JUMP_SLOT
];
241 case BFD_RELOC_386_RELATIVE
:
242 TRACE ("BFD_RELOC_386_RELATIVE");
243 return &elf_howto_table
[R_386_RELATIVE
];
245 case BFD_RELOC_386_GOTOFF
:
246 TRACE ("BFD_RELOC_386_GOTOFF");
247 return &elf_howto_table
[R_386_GOTOFF
];
249 case BFD_RELOC_386_GOTPC
:
250 TRACE ("BFD_RELOC_386_GOTPC");
251 return &elf_howto_table
[R_386_GOTPC
];
253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF
:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
256 return &elf_howto_table
[R_386_TLS_TPOFF
- R_386_ext_offset
];
258 case BFD_RELOC_386_TLS_IE
:
259 TRACE ("BFD_RELOC_386_TLS_IE");
260 return &elf_howto_table
[R_386_TLS_IE
- R_386_ext_offset
];
262 case BFD_RELOC_386_TLS_GOTIE
:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
264 return &elf_howto_table
[R_386_TLS_GOTIE
- R_386_ext_offset
];
266 case BFD_RELOC_386_TLS_LE
:
267 TRACE ("BFD_RELOC_386_TLS_LE");
268 return &elf_howto_table
[R_386_TLS_LE
- R_386_ext_offset
];
270 case BFD_RELOC_386_TLS_GD
:
271 TRACE ("BFD_RELOC_386_TLS_GD");
272 return &elf_howto_table
[R_386_TLS_GD
- R_386_ext_offset
];
274 case BFD_RELOC_386_TLS_LDM
:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
276 return &elf_howto_table
[R_386_TLS_LDM
- R_386_ext_offset
];
279 TRACE ("BFD_RELOC_16");
280 return &elf_howto_table
[R_386_16
- R_386_ext_offset
];
282 case BFD_RELOC_16_PCREL
:
283 TRACE ("BFD_RELOC_16_PCREL");
284 return &elf_howto_table
[R_386_PC16
- R_386_ext_offset
];
287 TRACE ("BFD_RELOC_8");
288 return &elf_howto_table
[R_386_8
- R_386_ext_offset
];
290 case BFD_RELOC_8_PCREL
:
291 TRACE ("BFD_RELOC_8_PCREL");
292 return &elf_howto_table
[R_386_PC8
- R_386_ext_offset
];
294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32
:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
297 return &elf_howto_table
[R_386_TLS_LDO_32
- R_386_tls_offset
];
299 case BFD_RELOC_386_TLS_IE_32
:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
301 return &elf_howto_table
[R_386_TLS_IE_32
- R_386_tls_offset
];
303 case BFD_RELOC_386_TLS_LE_32
:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
305 return &elf_howto_table
[R_386_TLS_LE_32
- R_386_tls_offset
];
307 case BFD_RELOC_386_TLS_DTPMOD32
:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
309 return &elf_howto_table
[R_386_TLS_DTPMOD32
- R_386_tls_offset
];
311 case BFD_RELOC_386_TLS_DTPOFF32
:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
313 return &elf_howto_table
[R_386_TLS_DTPOFF32
- R_386_tls_offset
];
315 case BFD_RELOC_386_TLS_TPOFF32
:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
317 return &elf_howto_table
[R_386_TLS_TPOFF32
- R_386_tls_offset
];
319 case BFD_RELOC_SIZE32
:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table
[R_386_SIZE32
- R_386_tls_offset
];
323 case BFD_RELOC_386_TLS_GOTDESC
:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table
[R_386_TLS_GOTDESC
- R_386_tls_offset
];
327 case BFD_RELOC_386_TLS_DESC_CALL
:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table
[R_386_TLS_DESC_CALL
- R_386_tls_offset
];
331 case BFD_RELOC_386_TLS_DESC
:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table
[R_386_TLS_DESC
- R_386_tls_offset
];
335 case BFD_RELOC_386_IRELATIVE
:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
337 return &elf_howto_table
[R_386_IRELATIVE
- R_386_tls_offset
];
339 case BFD_RELOC_386_GOT32X
:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table
[R_386_GOT32X
- R_386_tls_offset
];
343 case BFD_RELOC_VTABLE_INHERIT
:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
345 return &elf_howto_table
[R_386_GNU_VTINHERIT
- R_386_vt_offset
];
347 case BFD_RELOC_VTABLE_ENTRY
:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
349 return &elf_howto_table
[R_386_GNU_VTENTRY
- R_386_vt_offset
];
359 static reloc_howto_type
*
360 elf_i386_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
365 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
366 if (elf_howto_table
[i
].name
!= NULL
367 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
368 return &elf_howto_table
[i
];
373 static reloc_howto_type
*
374 elf_i386_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
378 if ((indx
= r_type
) >= R_386_standard
379 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
380 >= R_386_ext
- R_386_standard
)
381 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
382 >= R_386_ext2
- R_386_ext
)
383 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext2
384 >= R_386_vt
- R_386_ext2
))
386 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table
[indx
].type
!= r_type
)
393 return &elf_howto_table
[indx
];
397 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
399 Elf_Internal_Rela
*dst
)
401 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
402 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
405 /* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
412 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
414 if (name
[0] == '.' && name
[1] == 'X')
417 return _bfd_elf_is_local_label_name (abfd
, name
);
420 /* Support for core dump NOTE sections. */
423 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
428 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
430 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
436 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
439 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
443 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
447 switch (note
->descsz
)
452 case 144: /* Linux/i386 */
454 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
457 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
469 size
, note
->descpos
+ offset
);
473 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
475 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
477 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
482 elf_tdata (abfd
)->core
->program
483 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
484 elf_tdata (abfd
)->core
->command
485 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
489 switch (note
->descsz
)
494 case 124: /* Linux/i386 elf_prpsinfo. */
495 elf_tdata (abfd
)->core
->pid
496 = bfd_get_32 (abfd
, note
->descdata
+ 12);
497 elf_tdata (abfd
)->core
->program
498 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
499 elf_tdata (abfd
)->core
->command
500 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
508 char *command
= elf_tdata (abfd
)->core
->command
;
509 int n
= strlen (command
);
511 if (0 < n
&& command
[n
- 1] == ' ')
512 command
[n
- 1] = '\0';
518 /* Functions for the i386 ELF linker.
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
532 /* The name of the dynamic interpreter. This is put in the .interp
535 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the procedure linkage table. */
545 #define PLT_ENTRY_SIZE 16
547 /* The first entry in an absolute procedure linkage table looks like
548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
551 static const bfd_byte elf_i386_plt0_entry
[12] =
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0 /* replaced with address of .got + 8. */
559 /* Subsequent entries in an absolute procedure linkage table look like
562 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572 /* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
575 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
581 /* Subsequent entries in a PIC procedure linkage table look like this. */
583 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
593 /* Entries in the GOT procedure linkage table look like this. */
595 static const bfd_byte elf_i386_got_plt_entry
[8] =
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
602 /* Entries in the PIC GOT procedure linkage table look like this. */
604 static const bfd_byte elf_i386_pic_got_plt_entry
[8] =
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
611 /* .eh_frame covering the .plt section. */
613 static const bfd_byte elf_i386_eh_frame_plt
[] =
615 #define PLT_CIE_LENGTH 20
616 #define PLT_FDE_LENGTH 36
617 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
628 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop
, DW_CFA_nop
,
632 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
646 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
647 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
650 struct elf_i386_plt_layout
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte
*plt0_entry
;
654 unsigned int plt0_entry_size
;
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset
;
658 unsigned int plt0_got2_offset
;
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte
*plt_entry
;
662 unsigned int plt_entry_size
;
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset
;
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte
*pic_plt0_entry
;
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte
*pic_plt_entry
;
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte
*eh_frame_plt
;
680 unsigned int eh_frame_plt_size
;
683 #define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
686 /* These are the standard parameters. */
687 static const struct elf_i386_plt_layout elf_i386_plt
=
689 elf_i386_plt0_entry
, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry
), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry
, /* plt_entry */
694 PLT_ENTRY_SIZE
, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry
, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry
, /* pic_plt_entry */
701 elf_i386_eh_frame_plt
, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt
), /* eh_frame_plt_size */
706 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708 #define PLTRESOLVE_RELOCS_SHLIB 0
709 #define PLTRESOLVE_RELOCS 2
710 #define PLT_NON_JUMP_SLOT_RELOCS 2
712 /* Architecture-specific backend data for i386. */
714 struct elf_i386_backend_data
716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout
*plt
;
719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte
;
722 /* True if the target system is VxWorks. */
726 #define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
730 /* These are the standard parameters. */
731 static const struct elf_i386_backend_data elf_i386_arch_bed
=
733 &elf_i386_plt
, /* plt */
734 0, /* plt0_pad_byte */
738 #define elf_backend_arch_data &elf_i386_arch_bed
740 /* Is a undefined weak symbol which is resolved to 0. Reference to an
741 undefined weak symbol is resolved to 0 when building executable if
743 1. Has non-GOT/non-PLT relocations in text section. Or
744 2. Has no GOT/PLT relocation.
746 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
751 || (EH)->has_non_got_reloc \
752 || !(INFO)->dynamic_undefined_weak))
754 /* i386 ELF linker hash entry. */
756 struct elf_i386_link_hash_entry
758 struct elf_link_hash_entry elf
;
760 /* Track dynamic relocs copied for this symbol. */
761 struct elf_dyn_relocs
*dyn_relocs
;
763 #define GOT_UNKNOWN 0
767 #define GOT_TLS_IE_POS 5
768 #define GOT_TLS_IE_NEG 6
769 #define GOT_TLS_IE_BOTH 7
770 #define GOT_TLS_GDESC 8
771 #define GOT_TLS_GD_BOTH_P(type) \
772 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
773 #define GOT_TLS_GD_P(type) \
774 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
775 #define GOT_TLS_GDESC_P(type) \
776 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GD_ANY_P(type) \
778 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
779 unsigned char tls_type
;
781 /* Symbol is referenced by R_386_GOTOFF relocation. */
782 unsigned int gotoff_ref
: 1;
784 /* Symbol has GOT or PLT relocations. */
785 unsigned int has_got_reloc
: 1;
787 /* Symbol has non-GOT/non-PLT relocations in text sections. */
788 unsigned int has_non_got_reloc
: 1;
790 /* Reference count of C/C++ function pointer relocations in read-write
791 section which can be resolved at run-time. */
792 bfd_signed_vma func_pointer_refcount
;
794 /* Information about the GOT PLT entry. Filled when there are both
795 GOT and PLT relocations against the same function. */
796 union gotplt_union plt_got
;
798 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
799 starting at the end of the jump table. */
803 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
805 struct elf_i386_obj_tdata
807 struct elf_obj_tdata root
;
809 /* tls_type for each local got entry. */
810 char *local_got_tls_type
;
812 /* GOTPLT entries for TLS descriptors. */
813 bfd_vma
*local_tlsdesc_gotent
;
816 #define elf_i386_tdata(abfd) \
817 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
819 #define elf_i386_local_got_tls_type(abfd) \
820 (elf_i386_tdata (abfd)->local_got_tls_type)
822 #define elf_i386_local_tlsdesc_gotent(abfd) \
823 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
825 #define is_i386_elf(bfd) \
826 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
827 && elf_tdata (bfd) != NULL \
828 && elf_object_id (bfd) == I386_ELF_DATA)
831 elf_i386_mkobject (bfd
*abfd
)
833 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
837 /* i386 ELF linker hash table. */
839 struct elf_i386_link_hash_table
841 struct elf_link_hash_table elf
;
843 /* Short-cuts to get to dynamic linker sections. */
847 asection
*plt_eh_frame
;
852 bfd_signed_vma refcount
;
856 /* The amount of space used by the reserved portion of the sgotplt
857 section, plus whatever space is used by the jump slots. */
858 bfd_vma sgotplt_jump_table_size
;
860 /* Small local sym cache. */
861 struct sym_cache sym_cache
;
863 /* _TLS_MODULE_BASE_ symbol. */
864 struct bfd_link_hash_entry
*tls_module_base
;
866 /* Used by local STT_GNU_IFUNC symbols. */
867 htab_t loc_hash_table
;
868 void * loc_hash_memory
;
870 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
873 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
874 bfd_vma next_tls_desc_index
;
876 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
877 bfd_vma next_jump_slot_index
;
879 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
880 bfd_vma next_irelative_index
;
882 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
883 to read-only sections. */
884 bfd_boolean readonly_dynrelocs_against_ifunc
;
887 /* Get the i386 ELF linker hash table from a link_info structure. */
889 #define elf_i386_hash_table(p) \
890 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
891 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
893 #define elf_i386_compute_jump_table_size(htab) \
894 ((htab)->elf.srelplt->reloc_count * 4)
896 /* Create an entry in an i386 ELF linker hash table. */
898 static struct bfd_hash_entry
*
899 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
900 struct bfd_hash_table
*table
,
903 /* Allocate the structure if it has not already been allocated by a
907 entry
= (struct bfd_hash_entry
*)
908 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
913 /* Call the allocation method of the superclass. */
914 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
917 struct elf_i386_link_hash_entry
*eh
;
919 eh
= (struct elf_i386_link_hash_entry
*) entry
;
920 eh
->dyn_relocs
= NULL
;
921 eh
->tls_type
= GOT_UNKNOWN
;
923 eh
->has_got_reloc
= 0;
924 eh
->has_non_got_reloc
= 0;
925 eh
->func_pointer_refcount
= 0;
926 eh
->plt_got
.offset
= (bfd_vma
) -1;
927 eh
->tlsdesc_got
= (bfd_vma
) -1;
933 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
934 for local symbol so that we can handle local STT_GNU_IFUNC symbols
935 as global symbol. We reuse indx and dynstr_index for local symbol
936 hash since they aren't used by global symbols in this backend. */
939 elf_i386_local_htab_hash (const void *ptr
)
941 struct elf_link_hash_entry
*h
942 = (struct elf_link_hash_entry
*) ptr
;
943 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
946 /* Compare local hash entries. */
949 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
951 struct elf_link_hash_entry
*h1
952 = (struct elf_link_hash_entry
*) ptr1
;
953 struct elf_link_hash_entry
*h2
954 = (struct elf_link_hash_entry
*) ptr2
;
956 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
959 /* Find and/or create a hash entry for local symbol. */
961 static struct elf_link_hash_entry
*
962 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
963 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
966 struct elf_i386_link_hash_entry e
, *ret
;
967 asection
*sec
= abfd
->sections
;
968 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
969 ELF32_R_SYM (rel
->r_info
));
972 e
.elf
.indx
= sec
->id
;
973 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
974 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
975 create
? INSERT
: NO_INSERT
);
982 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
986 ret
= (struct elf_i386_link_hash_entry
*)
987 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
988 sizeof (struct elf_i386_link_hash_entry
));
991 memset (ret
, 0, sizeof (*ret
));
992 ret
->elf
.indx
= sec
->id
;
993 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
994 ret
->elf
.dynindx
= -1;
995 ret
->func_pointer_refcount
= 0;
996 ret
->plt_got
.offset
= (bfd_vma
) -1;
1002 /* Destroy an i386 ELF linker hash table. */
1005 elf_i386_link_hash_table_free (bfd
*obfd
)
1007 struct elf_i386_link_hash_table
*htab
1008 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1010 if (htab
->loc_hash_table
)
1011 htab_delete (htab
->loc_hash_table
);
1012 if (htab
->loc_hash_memory
)
1013 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1014 _bfd_elf_link_hash_table_free (obfd
);
1017 /* Create an i386 ELF linker hash table. */
1019 static struct bfd_link_hash_table
*
1020 elf_i386_link_hash_table_create (bfd
*abfd
)
1022 struct elf_i386_link_hash_table
*ret
;
1023 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1025 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1029 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1030 elf_i386_link_hash_newfunc
,
1031 sizeof (struct elf_i386_link_hash_entry
),
1038 ret
->loc_hash_table
= htab_try_create (1024,
1039 elf_i386_local_htab_hash
,
1040 elf_i386_local_htab_eq
,
1042 ret
->loc_hash_memory
= objalloc_create ();
1043 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1045 elf_i386_link_hash_table_free (abfd
);
1048 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1050 return &ret
->elf
.root
;
1053 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1054 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1060 struct elf_i386_link_hash_table
*htab
;
1062 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1065 htab
= elf_i386_hash_table (info
);
1069 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
1510 #define check_relocs_failed sec_flg1
1512 /* Look through the relocs for a section during the first phase, and
1513 calculate needed space in the global offset table, procedure linkage
1514 table, and dynamic reloc sections. */
1517 elf_i386_check_relocs (bfd
*abfd
,
1518 struct bfd_link_info
*info
,
1520 const Elf_Internal_Rela
*relocs
)
1522 struct elf_i386_link_hash_table
*htab
;
1523 Elf_Internal_Shdr
*symtab_hdr
;
1524 struct elf_link_hash_entry
**sym_hashes
;
1525 const Elf_Internal_Rela
*rel
;
1526 const Elf_Internal_Rela
*rel_end
;
1528 bfd_boolean use_plt_got
;
1530 if (bfd_link_relocatable (info
))
1533 BFD_ASSERT (is_i386_elf (abfd
));
1535 htab
= elf_i386_hash_table (info
);
1538 sec
->check_relocs_failed
= 1;
1542 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1543 && (get_elf_i386_backend_data (abfd
)
1544 == &elf_i386_arch_bed
));
1546 symtab_hdr
= &elf_symtab_hdr (abfd
);
1547 sym_hashes
= elf_sym_hashes (abfd
);
1551 rel_end
= relocs
+ sec
->reloc_count
;
1552 for (rel
= relocs
; rel
< rel_end
; rel
++)
1554 unsigned int r_type
;
1555 unsigned long r_symndx
;
1556 struct elf_link_hash_entry
*h
;
1557 struct elf_i386_link_hash_entry
*eh
;
1558 Elf_Internal_Sym
*isym
;
1560 bfd_boolean size_reloc
;
1562 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1563 r_type
= ELF32_R_TYPE (rel
->r_info
);
1565 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1567 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1573 if (r_symndx
< symtab_hdr
->sh_info
)
1575 /* A local symbol. */
1576 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1581 /* Check relocation against local STT_GNU_IFUNC symbol. */
1582 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1584 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1588 /* Fake a STT_GNU_IFUNC symbol. */
1589 h
->type
= STT_GNU_IFUNC
;
1592 h
->forced_local
= 1;
1593 h
->root
.type
= bfd_link_hash_defined
;
1601 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1602 while (h
->root
.type
== bfd_link_hash_indirect
1603 || h
->root
.type
== bfd_link_hash_warning
)
1604 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1607 eh
= (struct elf_i386_link_hash_entry
*) h
;
1622 if (htab
->elf
.dynobj
== NULL
)
1623 htab
->elf
.dynobj
= abfd
;
1624 /* Create the ifunc sections for static executables. */
1625 if (h
->type
== STT_GNU_IFUNC
1626 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1632 /* It is referenced by a non-shared object. */
1634 h
->root
.non_ir_ref
= 1;
1636 if (h
->type
== STT_GNU_IFUNC
)
1637 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1638 |= elf_gnu_symbol_ifunc
;
1641 if (! elf_i386_tls_transition (info
, abfd
, sec
, NULL
,
1642 symtab_hdr
, sym_hashes
,
1643 &r_type
, GOT_UNKNOWN
,
1644 rel
, rel_end
, h
, r_symndx
))
1650 htab
->tls_ldm_got
.refcount
+= 1;
1654 /* This symbol requires a procedure linkage table entry. We
1655 actually build the entry in adjust_dynamic_symbol,
1656 because this might be a case of linking PIC code which is
1657 never referenced by a dynamic object, in which case we
1658 don't need to generate a procedure linkage table entry
1661 /* If this is a local symbol, we resolve it directly without
1662 creating a procedure linkage table entry. */
1666 eh
->has_got_reloc
= 1;
1668 h
->plt
.refcount
+= 1;
1675 case R_386_TLS_IE_32
:
1677 case R_386_TLS_GOTIE
:
1678 if (!bfd_link_executable (info
))
1679 info
->flags
|= DF_STATIC_TLS
;
1685 case R_386_TLS_GOTDESC
:
1686 case R_386_TLS_DESC_CALL
:
1687 /* This symbol requires a global offset table entry. */
1689 int tls_type
, old_tls_type
;
1696 tls_type
= GOT_NORMAL
;
1698 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1699 case R_386_TLS_GOTDESC
:
1700 case R_386_TLS_DESC_CALL
:
1701 tls_type
= GOT_TLS_GDESC
; break;
1702 case R_386_TLS_IE_32
:
1703 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1704 tls_type
= GOT_TLS_IE_NEG
;
1706 /* If this is a GD->IE transition, we may use either of
1707 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1708 tls_type
= GOT_TLS_IE
;
1711 case R_386_TLS_GOTIE
:
1712 tls_type
= GOT_TLS_IE_POS
; break;
1717 h
->got
.refcount
+= 1;
1718 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1722 bfd_signed_vma
*local_got_refcounts
;
1724 /* This is a global offset table entry for a local symbol. */
1725 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1726 if (local_got_refcounts
== NULL
)
1730 size
= symtab_hdr
->sh_info
;
1731 size
*= (sizeof (bfd_signed_vma
)
1732 + sizeof (bfd_vma
) + sizeof(char));
1733 local_got_refcounts
= (bfd_signed_vma
*)
1734 bfd_zalloc (abfd
, size
);
1735 if (local_got_refcounts
== NULL
)
1737 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1738 elf_i386_local_tlsdesc_gotent (abfd
)
1739 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1740 elf_i386_local_got_tls_type (abfd
)
1741 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1743 local_got_refcounts
[r_symndx
] += 1;
1744 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1747 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1748 tls_type
|= old_tls_type
;
1749 /* If a TLS symbol is accessed using IE at least once,
1750 there is no point to use dynamic model for it. */
1751 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1752 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1753 || (tls_type
& GOT_TLS_IE
) == 0))
1755 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1756 tls_type
= old_tls_type
;
1757 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1758 && GOT_TLS_GD_ANY_P (tls_type
))
1759 tls_type
|= old_tls_type
;
1763 name
= h
->root
.root
.string
;
1765 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1767 (*_bfd_error_handler
)
1768 (_("%B: `%s' accessed both as normal and "
1769 "thread local symbol"),
1771 bfd_set_error (bfd_error_bad_value
);
1776 if (old_tls_type
!= tls_type
)
1779 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1781 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1789 if (htab
->elf
.sgot
== NULL
)
1791 if (htab
->elf
.dynobj
== NULL
)
1792 htab
->elf
.dynobj
= abfd
;
1793 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
1796 if (r_type
!= R_386_TLS_IE
)
1799 eh
->has_got_reloc
= 1;
1804 case R_386_TLS_LE_32
:
1807 eh
->has_got_reloc
= 1;
1808 if (bfd_link_executable (info
))
1810 info
->flags
|= DF_STATIC_TLS
;
1815 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
1816 eh
->has_non_got_reloc
= 1;
1818 /* STT_GNU_IFUNC symbol must go through PLT even if it is
1819 locally defined and undefined symbol may turn out to be
1820 a STT_GNU_IFUNC symbol later. */
1822 && (bfd_link_executable (info
)
1823 || ((h
->type
== STT_GNU_IFUNC
1824 || h
->root
.type
== bfd_link_hash_undefweak
1825 || h
->root
.type
== bfd_link_hash_undefined
)
1826 && SYMBOLIC_BIND (info
, h
))))
1828 /* If this reloc is in a read-only section, we might
1829 need a copy reloc. We can't check reliably at this
1830 stage whether the section is read-only, as input
1831 sections have not yet been mapped to output sections.
1832 Tentatively set the flag for now, and correct in
1833 adjust_dynamic_symbol. */
1836 /* We may need a .plt entry if the function this reloc
1837 refers to is in a shared lib. */
1838 h
->plt
.refcount
+= 1;
1839 if (r_type
== R_386_PC32
)
1841 /* Since something like ".long foo - ." may be used
1842 as pointer, make sure that PLT is used if foo is
1843 a function defined in a shared library. */
1844 if ((sec
->flags
& SEC_CODE
) == 0)
1845 h
->pointer_equality_needed
= 1;
1849 h
->pointer_equality_needed
= 1;
1850 /* R_386_32 can be resolved at run-time. */
1851 if (r_type
== R_386_32
1852 && (sec
->flags
& SEC_READONLY
) == 0)
1853 eh
->func_pointer_refcount
+= 1;
1859 /* If we are creating a shared library, and this is a reloc
1860 against a global symbol, or a non PC relative reloc
1861 against a local symbol, then we need to copy the reloc
1862 into the shared library. However, if we are linking with
1863 -Bsymbolic, we do not need to copy a reloc against a
1864 global symbol which is defined in an object we are
1865 including in the link (i.e., DEF_REGULAR is set). At
1866 this point we have not seen all the input files, so it is
1867 possible that DEF_REGULAR is not set now but will be set
1868 later (it is never cleared). In case of a weak definition,
1869 DEF_REGULAR may be cleared later by a strong definition in
1870 a shared library. We account for that possibility below by
1871 storing information in the relocs_copied field of the hash
1872 table entry. A similar situation occurs when creating
1873 shared libraries and symbol visibility changes render the
1876 If on the other hand, we are creating an executable, we
1877 may need to keep relocations for symbols satisfied by a
1878 dynamic library if we manage to avoid copy relocs for the
1880 if ((bfd_link_pic (info
)
1881 && (sec
->flags
& SEC_ALLOC
) != 0
1882 && (r_type
!= R_386_PC32
1884 && (! (bfd_link_pie (info
)
1885 || SYMBOLIC_BIND (info
, h
))
1886 || h
->root
.type
== bfd_link_hash_defweak
1887 || !h
->def_regular
))))
1888 || (ELIMINATE_COPY_RELOCS
1889 && !bfd_link_pic (info
)
1890 && (sec
->flags
& SEC_ALLOC
) != 0
1892 && (h
->root
.type
== bfd_link_hash_defweak
1893 || !h
->def_regular
)))
1895 struct elf_dyn_relocs
*p
;
1896 struct elf_dyn_relocs
**head
;
1898 /* We must copy these reloc types into the output file.
1899 Create a reloc section in dynobj and make room for
1903 if (htab
->elf
.dynobj
== NULL
)
1904 htab
->elf
.dynobj
= abfd
;
1906 sreloc
= _bfd_elf_make_dynamic_reloc_section
1907 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
1913 /* If this is a global symbol, we count the number of
1914 relocations we need for this symbol. */
1917 head
= &eh
->dyn_relocs
;
1921 /* Track dynamic relocs needed for local syms too.
1922 We really need local syms available to do this
1927 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1932 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1936 vpp
= &elf_section_data (s
)->local_dynrel
;
1937 head
= (struct elf_dyn_relocs
**)vpp
;
1941 if (p
== NULL
|| p
->sec
!= sec
)
1943 bfd_size_type amt
= sizeof *p
;
1944 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
1956 /* Count size relocation as PC-relative relocation. */
1957 if (r_type
== R_386_PC32
|| size_reloc
)
1962 /* This relocation describes the C++ object vtable hierarchy.
1963 Reconstruct it for later use during GC. */
1964 case R_386_GNU_VTINHERIT
:
1965 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1969 /* This relocation describes which C++ vtable entries are actually
1970 used. Record for later use during GC. */
1971 case R_386_GNU_VTENTRY
:
1972 BFD_ASSERT (h
!= NULL
);
1974 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1984 && h
->plt
.refcount
> 0
1985 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
1986 || h
->got
.refcount
> 0)
1987 && htab
->plt_got
== NULL
)
1989 /* Create the GOT procedure linkage table. */
1990 unsigned int plt_got_align
;
1991 const struct elf_backend_data
*bed
;
1993 bed
= get_elf_backend_data (info
->output_bfd
);
1994 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
1995 && (sizeof (elf_i386_got_plt_entry
)
1996 == sizeof (elf_i386_pic_got_plt_entry
)));
1999 if (htab
->elf
.dynobj
== NULL
)
2000 htab
->elf
.dynobj
= abfd
;
2002 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2004 (bed
->dynamic_sec_flags
2009 if (htab
->plt_got
== NULL
2010 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2016 if ((r_type
== R_386_GOT32
|| r_type
== R_386_GOT32X
)
2017 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2018 sec
->need_convert_load
= 1;
2024 sec
->check_relocs_failed
= 1;
2028 /* Return the section that should be marked against GC for a given
2032 elf_i386_gc_mark_hook (asection
*sec
,
2033 struct bfd_link_info
*info
,
2034 Elf_Internal_Rela
*rel
,
2035 struct elf_link_hash_entry
*h
,
2036 Elf_Internal_Sym
*sym
)
2039 switch (ELF32_R_TYPE (rel
->r_info
))
2041 case R_386_GNU_VTINHERIT
:
2042 case R_386_GNU_VTENTRY
:
2046 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2049 /* Remove undefined weak symbol from the dynamic symbol table if it
2050 is resolved to 0. */
2053 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2054 struct elf_link_hash_entry
*h
)
2056 if (h
->dynindx
!= -1
2057 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2058 elf_i386_hash_entry (h
)->has_got_reloc
,
2059 elf_i386_hash_entry (h
)))
2062 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2068 /* Adjust a symbol defined by a dynamic object and referenced by a
2069 regular object. The current definition is in some section of the
2070 dynamic object, but we're not including those sections. We have to
2071 change the definition to something the rest of the link can
2075 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2076 struct elf_link_hash_entry
*h
)
2078 struct elf_i386_link_hash_table
*htab
;
2080 struct elf_i386_link_hash_entry
*eh
;
2081 struct elf_dyn_relocs
*p
;
2083 /* STT_GNU_IFUNC symbol must go through PLT. */
2084 if (h
->type
== STT_GNU_IFUNC
)
2086 /* All local STT_GNU_IFUNC references must be treate as local
2087 calls via local PLT. */
2089 && SYMBOL_CALLS_LOCAL (info
, h
))
2091 bfd_size_type pc_count
= 0, count
= 0;
2092 struct elf_dyn_relocs
**pp
;
2094 eh
= (struct elf_i386_link_hash_entry
*) h
;
2095 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2097 pc_count
+= p
->pc_count
;
2098 p
->count
-= p
->pc_count
;
2107 if (pc_count
|| count
)
2111 if (h
->plt
.refcount
<= 0)
2112 h
->plt
.refcount
= 1;
2114 h
->plt
.refcount
+= 1;
2118 if (h
->plt
.refcount
<= 0)
2120 h
->plt
.offset
= (bfd_vma
) -1;
2126 /* If this is a function, put it in the procedure linkage table. We
2127 will fill in the contents of the procedure linkage table later,
2128 when we know the address of the .got section. */
2129 if (h
->type
== STT_FUNC
2132 if (h
->plt
.refcount
<= 0
2133 || SYMBOL_CALLS_LOCAL (info
, h
)
2134 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2135 && h
->root
.type
== bfd_link_hash_undefweak
))
2137 /* This case can occur if we saw a PLT32 reloc in an input
2138 file, but the symbol was never referred to by a dynamic
2139 object, or if all references were garbage collected. In
2140 such a case, we don't actually need to build a procedure
2141 linkage table, and we can just do a PC32 reloc instead. */
2142 h
->plt
.offset
= (bfd_vma
) -1;
2149 /* It's possible that we incorrectly decided a .plt reloc was
2150 needed for an R_386_PC32 reloc to a non-function sym in
2151 check_relocs. We can't decide accurately between function and
2152 non-function syms in check-relocs; Objects loaded later in
2153 the link may change h->type. So fix it now. */
2154 h
->plt
.offset
= (bfd_vma
) -1;
2156 /* If this is a weak symbol, and there is a real definition, the
2157 processor independent code will have arranged for us to see the
2158 real definition first, and we can just use the same value. */
2159 if (h
->u
.weakdef
!= NULL
)
2161 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2162 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2163 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2164 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2165 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2166 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2170 /* This is a reference to a symbol defined by a dynamic object which
2171 is not a function. */
2173 /* If we are creating a shared library, we must presume that the
2174 only references to the symbol are via the global offset table.
2175 For such cases we need not do anything here; the relocations will
2176 be handled correctly by relocate_section. */
2177 if (!bfd_link_executable (info
))
2180 /* If there are no references to this symbol that do not use the
2181 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2183 eh
= (struct elf_i386_link_hash_entry
*) h
;
2184 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2187 /* If -z nocopyreloc was given, we won't generate them either. */
2188 if (info
->nocopyreloc
)
2194 htab
= elf_i386_hash_table (info
);
2198 /* If there aren't any dynamic relocs in read-only sections nor
2199 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2200 avoid the copy reloc. This doesn't work on VxWorks, where we can
2201 not have dynamic relocations (other than copy and jump slot
2202 relocations) in an executable. */
2203 if (ELIMINATE_COPY_RELOCS
2205 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2207 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2209 s
= p
->sec
->output_section
;
2210 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2221 /* We must allocate the symbol in our .dynbss section, which will
2222 become part of the .bss section of the executable. There will be
2223 an entry for this symbol in the .dynsym section. The dynamic
2224 object will contain position independent code, so all references
2225 from the dynamic object to this symbol will go through the global
2226 offset table. The dynamic linker will use the .dynsym entry to
2227 determine the address it must put in the global offset table, so
2228 both the dynamic object and the regular object will refer to the
2229 same memory location for the variable. */
2231 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2232 copy the initial value out of the dynamic object and into the
2233 runtime process image. */
2234 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2236 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2242 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2245 /* Allocate space in .plt, .got and associated reloc sections for
2249 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2251 struct bfd_link_info
*info
;
2252 struct elf_i386_link_hash_table
*htab
;
2253 struct elf_i386_link_hash_entry
*eh
;
2254 struct elf_dyn_relocs
*p
;
2255 unsigned plt_entry_size
;
2256 bfd_boolean resolved_to_zero
;
2258 if (h
->root
.type
== bfd_link_hash_indirect
)
2261 eh
= (struct elf_i386_link_hash_entry
*) h
;
2263 info
= (struct bfd_link_info
*) inf
;
2264 htab
= elf_i386_hash_table (info
);
2268 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2270 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2274 /* Clear the reference count of function pointer relocations if
2275 symbol isn't a normal function. */
2276 if (h
->type
!= STT_FUNC
)
2277 eh
->func_pointer_refcount
= 0;
2279 /* We can't use the GOT PLT if pointer equality is needed since
2280 finish_dynamic_symbol won't clear symbol value and the dynamic
2281 linker won't update the GOT slot. We will get into an infinite
2282 loop at run-time. */
2283 if (htab
->plt_got
!= NULL
2284 && h
->type
!= STT_GNU_IFUNC
2285 && !h
->pointer_equality_needed
2286 && h
->plt
.refcount
> 0
2287 && h
->got
.refcount
> 0)
2289 /* Don't use the regular PLT if there are both GOT and GOTPLT
2291 h
->plt
.offset
= (bfd_vma
) -1;
2293 /* Use the GOT PLT. */
2294 eh
->plt_got
.refcount
= 1;
2297 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2298 here if it is defined and referenced in a non-shared object. */
2299 if (h
->type
== STT_GNU_IFUNC
2301 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2302 &htab
->readonly_dynrelocs_against_ifunc
,
2305 /* Don't create the PLT entry if there are only function pointer
2306 relocations which can be resolved at run-time. */
2307 else if (htab
->elf
.dynamic_sections_created
2308 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2309 || eh
->plt_got
.refcount
> 0))
2311 bfd_boolean use_plt_got
;
2313 /* Clear the reference count of function pointer relocations
2315 eh
->func_pointer_refcount
= 0;
2317 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2319 /* Don't use the regular PLT for DF_BIND_NOW. */
2320 h
->plt
.offset
= (bfd_vma
) -1;
2322 /* Use the GOT PLT. */
2323 h
->got
.refcount
= 1;
2324 eh
->plt_got
.refcount
= 1;
2327 use_plt_got
= eh
->plt_got
.refcount
> 0;
2329 /* Make sure this symbol is output as a dynamic symbol.
2330 Undefined weak syms won't yet be marked as dynamic. */
2331 if (h
->dynindx
== -1
2333 && !resolved_to_zero
)
2335 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2339 if (bfd_link_pic (info
)
2340 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2342 asection
*s
= htab
->elf
.splt
;
2343 asection
*got_s
= htab
->plt_got
;
2345 /* If this is the first .plt entry, make room for the special
2346 first entry. The .plt section is used by prelink to undo
2347 prelinking for dynamic relocations. */
2349 s
->size
= plt_entry_size
;
2352 eh
->plt_got
.offset
= got_s
->size
;
2354 h
->plt
.offset
= s
->size
;
2356 /* If this symbol is not defined in a regular file, and we are
2357 not generating a shared library, then set the symbol to this
2358 location in the .plt. This is required to make function
2359 pointers compare as equal between the normal executable and
2360 the shared library. */
2361 if (! bfd_link_pic (info
)
2366 /* We need to make a call to the entry of the GOT PLT
2367 instead of regular PLT entry. */
2368 h
->root
.u
.def
.section
= got_s
;
2369 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2373 h
->root
.u
.def
.section
= s
;
2374 h
->root
.u
.def
.value
= h
->plt
.offset
;
2378 /* Make room for this entry. */
2380 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2383 s
->size
+= plt_entry_size
;
2385 /* We also need to make an entry in the .got.plt section,
2386 which will be placed in the .got section by the linker
2388 htab
->elf
.sgotplt
->size
+= 4;
2390 /* There should be no PLT relocation against resolved
2391 undefined weak symbol in executable. */
2392 if (!resolved_to_zero
)
2394 /* We also need to make an entry in the .rel.plt
2396 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2397 htab
->elf
.srelplt
->reloc_count
++;
2401 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2402 && !bfd_link_pic (info
))
2404 /* VxWorks has a second set of relocations for each PLT entry
2405 in executables. They go in a separate relocation section,
2406 which is processed by the kernel loader. */
2408 /* There are two relocations for the initial PLT entry: an
2409 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2410 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2412 if (h
->plt
.offset
== plt_entry_size
)
2413 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2415 /* There are two extra relocations for each subsequent PLT entry:
2416 an R_386_32 relocation for the GOT entry, and an R_386_32
2417 relocation for the PLT entry. */
2419 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2424 eh
->plt_got
.offset
= (bfd_vma
) -1;
2425 h
->plt
.offset
= (bfd_vma
) -1;
2431 eh
->plt_got
.offset
= (bfd_vma
) -1;
2432 h
->plt
.offset
= (bfd_vma
) -1;
2436 eh
->tlsdesc_got
= (bfd_vma
) -1;
2438 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2439 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2440 if (h
->got
.refcount
> 0
2441 && bfd_link_executable (info
)
2443 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2444 h
->got
.offset
= (bfd_vma
) -1;
2445 else if (h
->got
.refcount
> 0)
2449 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2451 /* Make sure this symbol is output as a dynamic symbol.
2452 Undefined weak syms won't yet be marked as dynamic. */
2453 if (h
->dynindx
== -1
2455 && !resolved_to_zero
)
2457 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2462 if (GOT_TLS_GDESC_P (tls_type
))
2464 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2465 - elf_i386_compute_jump_table_size (htab
);
2466 htab
->elf
.sgotplt
->size
+= 8;
2467 h
->got
.offset
= (bfd_vma
) -2;
2469 if (! GOT_TLS_GDESC_P (tls_type
)
2470 || GOT_TLS_GD_P (tls_type
))
2472 h
->got
.offset
= s
->size
;
2474 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2475 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2478 dyn
= htab
->elf
.dynamic_sections_created
;
2479 /* R_386_TLS_IE_32 needs one dynamic relocation,
2480 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2481 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2482 need two), R_386_TLS_GD needs one if local symbol and two if
2483 global. No dynamic relocation against resolved undefined weak
2484 symbol in executable. */
2485 if (tls_type
== GOT_TLS_IE_BOTH
)
2486 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2487 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2488 || (tls_type
& GOT_TLS_IE
))
2489 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2490 else if (GOT_TLS_GD_P (tls_type
))
2491 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2492 else if (! GOT_TLS_GDESC_P (tls_type
)
2493 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2494 && !resolved_to_zero
)
2495 || h
->root
.type
!= bfd_link_hash_undefweak
)
2496 && (bfd_link_pic (info
)
2497 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2498 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2499 if (GOT_TLS_GDESC_P (tls_type
))
2500 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2503 h
->got
.offset
= (bfd_vma
) -1;
2505 if (eh
->dyn_relocs
== NULL
)
2508 /* In the shared -Bsymbolic case, discard space allocated for
2509 dynamic pc-relative relocs against symbols which turn out to be
2510 defined in regular objects. For the normal shared case, discard
2511 space for pc-relative relocs that have become local due to symbol
2512 visibility changes. */
2514 if (bfd_link_pic (info
))
2516 /* The only reloc that uses pc_count is R_386_PC32, which will
2517 appear on a call or on something like ".long foo - .". We
2518 want calls to protected symbols to resolve directly to the
2519 function rather than going via the plt. If people want
2520 function pointer comparisons to work as expected then they
2521 should avoid writing assembly like ".long foo - .". */
2522 if (SYMBOL_CALLS_LOCAL (info
, h
))
2524 struct elf_dyn_relocs
**pp
;
2526 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2528 p
->count
-= p
->pc_count
;
2537 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2539 struct elf_dyn_relocs
**pp
;
2540 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2542 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2549 /* Also discard relocs on undefined weak syms with non-default
2550 visibility or in PIE. */
2551 if (eh
->dyn_relocs
!= NULL
2552 && h
->root
.type
== bfd_link_hash_undefweak
)
2554 /* Undefined weak symbol is never bound locally in shared
2556 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2557 || resolved_to_zero
)
2561 /* Keep dynamic non-GOT/non-PLT relocation so that we
2562 can branch to 0 without PLT. */
2563 struct elf_dyn_relocs
**pp
;
2565 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2566 if (p
->pc_count
== 0)
2570 /* Remove non-R_386_PC32 relocation. */
2571 p
->count
= p
->pc_count
;
2575 if (eh
->dyn_relocs
!= NULL
)
2577 /* Make sure undefined weak symbols are output
2578 as dynamic symbols in PIEs for dynamic non-GOT
2579 non-PLT reloations. */
2580 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2585 eh
->dyn_relocs
= NULL
;
2587 else if (h
->dynindx
== -1
2588 && !h
->forced_local
)
2590 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2595 else if (ELIMINATE_COPY_RELOCS
)
2597 /* For the non-shared case, discard space for relocs against
2598 symbols which turn out to need copy relocs or are not
2599 dynamic. Keep dynamic relocations for run-time function
2600 pointer initialization. */
2602 if ((!h
->non_got_ref
2603 || eh
->func_pointer_refcount
> 0
2604 || (h
->root
.type
== bfd_link_hash_undefweak
2605 && !resolved_to_zero
))
2608 || (htab
->elf
.dynamic_sections_created
2609 && (h
->root
.type
== bfd_link_hash_undefweak
2610 || h
->root
.type
== bfd_link_hash_undefined
))))
2612 /* Make sure this symbol is output as a dynamic symbol.
2613 Undefined weak syms won't yet be marked as dynamic. */
2614 if (h
->dynindx
== -1
2616 && !resolved_to_zero
)
2618 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2622 /* If that succeeded, we know we'll be keeping all the
2624 if (h
->dynindx
!= -1)
2628 eh
->dyn_relocs
= NULL
;
2629 eh
->func_pointer_refcount
= 0;
2634 /* Finally, allocate space. */
2635 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2639 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2641 BFD_ASSERT (sreloc
!= NULL
);
2642 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
2648 /* Allocate space in .plt, .got and associated reloc sections for
2649 local dynamic relocs. */
2652 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
2654 struct elf_link_hash_entry
*h
2655 = (struct elf_link_hash_entry
*) *slot
;
2657 if (h
->type
!= STT_GNU_IFUNC
2661 || h
->root
.type
!= bfd_link_hash_defined
)
2664 return elf_i386_allocate_dynrelocs (h
, inf
);
2667 /* Find any dynamic relocs that apply to read-only sections. */
2670 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2672 struct elf_i386_link_hash_entry
*eh
;
2673 struct elf_dyn_relocs
*p
;
2675 /* Skip local IFUNC symbols. */
2676 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2679 eh
= (struct elf_i386_link_hash_entry
*) h
;
2680 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2682 asection
*s
= p
->sec
->output_section
;
2684 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2686 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2688 info
->flags
|= DF_TEXTREL
;
2690 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2691 || info
->error_textrel
)
2692 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2693 p
->sec
->owner
, h
->root
.root
.string
,
2696 /* Not an error, just cut short the traversal. */
2703 /* With the local symbol, foo, we convert
2704 mov foo@GOT[(%reg1)], %reg2
2706 lea foo[@GOTOFF(%reg1)], %reg2
2708 call/jmp *foo@GOT[(%reg)]
2710 nop call foo/jmp foo nop
2711 When PIC is false, convert
2712 test %reg1, foo@GOT[(%reg2)]
2716 binop foo@GOT[(%reg1)], %reg2
2719 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2723 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
2724 struct bfd_link_info
*link_info
)
2726 Elf_Internal_Shdr
*symtab_hdr
;
2727 Elf_Internal_Rela
*internal_relocs
;
2728 Elf_Internal_Rela
*irel
, *irelend
;
2730 struct elf_i386_link_hash_table
*htab
;
2731 bfd_boolean changed_contents
;
2732 bfd_boolean changed_relocs
;
2734 bfd_signed_vma
*local_got_refcounts
;
2736 /* Don't even try to convert non-ELF outputs. */
2737 if (!is_elf_hash_table (link_info
->hash
))
2740 /* Nothing to do if there is no need or no output. */
2741 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2742 || sec
->need_convert_load
== 0
2743 || bfd_is_abs_section (sec
->output_section
))
2746 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2748 /* Load the relocations for this section. */
2749 internal_relocs
= (_bfd_elf_link_read_relocs
2750 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2751 link_info
->keep_memory
));
2752 if (internal_relocs
== NULL
)
2755 htab
= elf_i386_hash_table (link_info
);
2756 changed_contents
= FALSE
;
2757 changed_relocs
= FALSE
;
2758 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2760 is_pic
= bfd_link_pic (link_info
);
2762 /* Get the section contents. */
2763 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2764 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2767 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2771 irelend
= internal_relocs
+ sec
->reloc_count
;
2772 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2774 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2775 unsigned int r_symndx
= ELF32_R_SYM (irel
->r_info
);
2777 struct elf_link_hash_entry
*h
;
2778 unsigned int opcode
;
2781 bfd_boolean baseless
;
2782 Elf_Internal_Sym
*isym
;
2783 unsigned int addend
;
2786 bfd_boolean to_reloc_32
;
2788 if (r_type
!= R_386_GOT32
&& r_type
!= R_386_GOT32X
)
2791 roff
= irel
->r_offset
;
2795 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
2796 addend
= bfd_get_32 (abfd
, contents
+ roff
);
2800 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2801 baseless
= (modrm
& 0xc7) == 0x5;
2803 if (r_type
== R_386_GOT32X
&& baseless
&& is_pic
)
2805 /* For PIC, disallow R_386_GOT32X without a base register
2806 since we don't know what the GOT base is. Allow
2807 R_386_GOT32 for existing object files. */
2810 if (r_symndx
< symtab_hdr
->sh_info
)
2812 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
2814 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
2818 indx
= r_symndx
- symtab_hdr
->sh_info
;
2819 h
= elf_sym_hashes (abfd
)[indx
];
2820 BFD_ASSERT (h
!= NULL
);
2821 name
= h
->root
.root
.string
;
2824 (*_bfd_error_handler
)
2825 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
2830 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
2832 /* Convert mov to lea since it has been done for a while. */
2835 /* Only convert R_386_GOT32X relocation for call, jmp or
2836 one of adc, add, and, cmp, or, sbb, sub, test, xor
2838 if (r_type
!= R_386_GOT32X
)
2842 /* Convert to R_386_32 if PIC is false or there is no base
2844 to_reloc_32
= !is_pic
|| baseless
;
2846 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
2847 referred to by the reloc. */
2848 if (r_symndx
< symtab_hdr
->sh_info
)
2850 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2853 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2854 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2858 if (opcode
== 0x0ff)
2859 /* Convert "call/jmp *foo@GOT[(%reg)]". */
2860 goto convert_branch
;
2862 /* Convert "mov foo@GOT[(%reg1)], %reg2",
2863 "test %reg1, foo@GOT(%reg2)" and
2864 "binop foo@GOT[(%reg1)], %reg2". */
2868 indx
= r_symndx
- symtab_hdr
->sh_info
;
2869 h
= elf_sym_hashes (abfd
)[indx
];
2870 BFD_ASSERT (h
!= NULL
);
2872 while (h
->root
.type
== bfd_link_hash_indirect
2873 || h
->root
.type
== bfd_link_hash_warning
)
2874 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2876 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2877 if (h
->type
== STT_GNU_IFUNC
)
2880 /* Undefined weak symbol is only bound locally in executable
2881 and its reference is resolved as 0. */
2882 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
2883 elf_i386_hash_entry (h
)))
2887 /* No direct branch to 0 for PIC. */
2891 goto convert_branch
;
2895 /* We can convert load of address 0 to R_386_32. */
2903 /* We have "call/jmp *foo@GOT[(%reg)]". */
2904 if ((h
->root
.type
== bfd_link_hash_defined
2905 || h
->root
.type
== bfd_link_hash_defweak
)
2906 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2908 /* The function is locally defined. */
2910 /* Convert R_386_GOT32X to R_386_PC32. */
2911 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
2913 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2916 nop
= link_info
->call_nop_byte
;
2917 if (link_info
->call_nop_as_suffix
)
2919 nop_offset
= roff
+ 3;
2920 irel
->r_offset
-= 1;
2923 nop_offset
= roff
- 2;
2927 /* Convert to "jmp foo nop". */
2930 nop_offset
= roff
+ 3;
2931 irel
->r_offset
-= 1;
2934 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2935 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2936 /* When converting to PC-relative relocation, we
2937 need to adjust addend by -4. */
2938 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
2939 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
2943 if (h
->got
.refcount
> 0)
2944 h
->got
.refcount
-= 1;
2948 if (local_got_refcounts
!= NULL
2949 && local_got_refcounts
[r_symndx
] > 0)
2950 local_got_refcounts
[r_symndx
] -= 1;
2953 changed_contents
= TRUE
;
2954 changed_relocs
= TRUE
;
2959 /* We have "mov foo@GOT[(%re1g)], %reg2",
2960 "test %reg1, foo@GOT(%reg2)" and
2961 "binop foo@GOT[(%reg1)], %reg2".
2963 Avoid optimizing _DYNAMIC since ld.so may use its
2964 link-time address. */
2965 if (h
== htab
->elf
.hdynamic
)
2968 /* def_regular is set by an assignment in a linker script in
2969 bfd_elf_record_link_assignment. */
2971 || h
->root
.type
== bfd_link_hash_defined
2972 || h
->root
.type
== bfd_link_hash_defweak
)
2973 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
2980 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
2981 "mov $foo, %reg2" with R_386_32. */
2983 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2984 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2989 /* Convert "mov foo@GOT(%reg1), %reg2" to
2990 "lea foo@GOTOFF(%reg1), %reg2". */
2991 r_type
= R_386_GOTOFF
;
2997 /* Only R_386_32 is supported. */
3003 /* Convert "test %reg1, foo@GOT(%reg2)" to
3004 "test $foo, %reg1". */
3005 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3010 /* Convert "binop foo@GOT(%reg1), %reg2" to
3011 "binop $foo, %reg2". */
3013 | (modrm
& 0x38) >> 3
3017 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3021 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3022 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3026 if (h
->got
.refcount
> 0)
3027 h
->got
.refcount
-= 1;
3031 if (local_got_refcounts
!= NULL
3032 && local_got_refcounts
[r_symndx
] > 0)
3033 local_got_refcounts
[r_symndx
] -= 1;
3036 changed_contents
= TRUE
;
3037 changed_relocs
= TRUE
;
3042 if (contents
!= NULL
3043 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3045 if (!changed_contents
&& !link_info
->keep_memory
)
3049 /* Cache the section contents for elf_link_input_bfd. */
3050 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3054 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3056 if (!changed_relocs
)
3057 free (internal_relocs
);
3059 elf_section_data (sec
)->relocs
= internal_relocs
;
3065 if (contents
!= NULL
3066 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3068 if (internal_relocs
!= NULL
3069 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3070 free (internal_relocs
);
3074 /* Set the sizes of the dynamic sections. */
3077 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3079 struct elf_i386_link_hash_table
*htab
;
3085 htab
= elf_i386_hash_table (info
);
3088 dynobj
= htab
->elf
.dynobj
;
3092 if (htab
->elf
.dynamic_sections_created
)
3094 /* Set the contents of the .interp section to the interpreter. */
3095 if (bfd_link_executable (info
) && !info
->nointerp
)
3097 s
= bfd_get_linker_section (dynobj
, ".interp");
3100 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3101 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3106 /* Set up .got offsets for local syms, and space for local dynamic
3108 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3110 bfd_signed_vma
*local_got
;
3111 bfd_signed_vma
*end_local_got
;
3112 char *local_tls_type
;
3113 bfd_vma
*local_tlsdesc_gotent
;
3114 bfd_size_type locsymcount
;
3115 Elf_Internal_Shdr
*symtab_hdr
;
3118 if (! is_i386_elf (ibfd
))
3121 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3123 struct elf_dyn_relocs
*p
;
3125 if (!elf_i386_convert_load (ibfd
, s
, info
))
3128 for (p
= ((struct elf_dyn_relocs
*)
3129 elf_section_data (s
)->local_dynrel
);
3133 if (!bfd_is_abs_section (p
->sec
)
3134 && bfd_is_abs_section (p
->sec
->output_section
))
3136 /* Input section has been discarded, either because
3137 it is a copy of a linkonce section or due to
3138 linker script /DISCARD/, so we'll be discarding
3141 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3142 && strcmp (p
->sec
->output_section
->name
,
3145 /* Relocations in vxworks .tls_vars sections are
3146 handled specially by the loader. */
3148 else if (p
->count
!= 0)
3150 srel
= elf_section_data (p
->sec
)->sreloc
;
3151 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3152 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3153 && (info
->flags
& DF_TEXTREL
) == 0)
3155 info
->flags
|= DF_TEXTREL
;
3156 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3157 || info
->error_textrel
)
3158 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3159 p
->sec
->owner
, p
->sec
);
3165 local_got
= elf_local_got_refcounts (ibfd
);
3169 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3170 locsymcount
= symtab_hdr
->sh_info
;
3171 end_local_got
= local_got
+ locsymcount
;
3172 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3173 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3175 srel
= htab
->elf
.srelgot
;
3176 for (; local_got
< end_local_got
;
3177 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3179 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3182 if (GOT_TLS_GDESC_P (*local_tls_type
))
3184 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3185 - elf_i386_compute_jump_table_size (htab
);
3186 htab
->elf
.sgotplt
->size
+= 8;
3187 *local_got
= (bfd_vma
) -2;
3189 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3190 || GOT_TLS_GD_P (*local_tls_type
))
3192 *local_got
= s
->size
;
3194 if (GOT_TLS_GD_P (*local_tls_type
)
3195 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3198 if (bfd_link_pic (info
)
3199 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3200 || (*local_tls_type
& GOT_TLS_IE
))
3202 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3203 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3204 else if (GOT_TLS_GD_P (*local_tls_type
)
3205 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3206 srel
->size
+= sizeof (Elf32_External_Rel
);
3207 if (GOT_TLS_GDESC_P (*local_tls_type
))
3208 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3212 *local_got
= (bfd_vma
) -1;
3216 if (htab
->tls_ldm_got
.refcount
> 0)
3218 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3220 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3221 htab
->elf
.sgot
->size
+= 8;
3222 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3225 htab
->tls_ldm_got
.offset
= -1;
3227 /* Allocate global sym .plt and .got entries, and space for global
3228 sym dynamic relocs. */
3229 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3231 /* Allocate .plt and .got entries, and space for local symbols. */
3232 htab_traverse (htab
->loc_hash_table
,
3233 elf_i386_allocate_local_dynrelocs
,
3236 /* For every jump slot reserved in the sgotplt, reloc_count is
3237 incremented. However, when we reserve space for TLS descriptors,
3238 it's not incremented, so in order to compute the space reserved
3239 for them, it suffices to multiply the reloc count by the jump
3242 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3243 so that R_386_IRELATIVE entries come last. */
3244 if (htab
->elf
.srelplt
)
3246 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3247 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3248 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3250 else if (htab
->elf
.irelplt
)
3251 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3254 if (htab
->elf
.sgotplt
)
3256 /* Don't allocate .got.plt section if there are no GOT nor PLT
3257 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3258 if ((htab
->elf
.hgot
== NULL
3259 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3260 && (htab
->elf
.sgotplt
->size
3261 == get_elf_backend_data (output_bfd
)->got_header_size
)
3262 && (htab
->elf
.splt
== NULL
3263 || htab
->elf
.splt
->size
== 0)
3264 && (htab
->elf
.sgot
== NULL
3265 || htab
->elf
.sgot
->size
== 0)
3266 && (htab
->elf
.iplt
== NULL
3267 || htab
->elf
.iplt
->size
== 0)
3268 && (htab
->elf
.igotplt
== NULL
3269 || htab
->elf
.igotplt
->size
== 0))
3270 htab
->elf
.sgotplt
->size
= 0;
3274 if (htab
->plt_eh_frame
!= NULL
3275 && htab
->elf
.splt
!= NULL
3276 && htab
->elf
.splt
->size
!= 0
3277 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3278 && _bfd_elf_eh_frame_present (info
))
3279 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3281 /* We now have determined the sizes of the various dynamic sections.
3282 Allocate memory for them. */
3284 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3286 bfd_boolean strip_section
= TRUE
;
3288 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3291 if (s
== htab
->elf
.splt
3292 || s
== htab
->elf
.sgot
)
3294 /* Strip this section if we don't need it; see the
3296 /* We'd like to strip these sections if they aren't needed, but if
3297 we've exported dynamic symbols from them we must leave them.
3298 It's too late to tell BFD to get rid of the symbols. */
3300 if (htab
->elf
.hplt
!= NULL
)
3301 strip_section
= FALSE
;
3303 else if (s
== htab
->elf
.sgotplt
3304 || s
== htab
->elf
.iplt
3305 || s
== htab
->elf
.igotplt
3306 || s
== htab
->plt_got
3307 || s
== htab
->plt_eh_frame
3308 || s
== htab
->sdynbss
)
3310 /* Strip these too. */
3312 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3315 && s
!= htab
->elf
.srelplt
3316 && s
!= htab
->srelplt2
)
3319 /* We use the reloc_count field as a counter if we need
3320 to copy relocs into the output file. */
3325 /* It's not one of our sections, so don't allocate space. */
3331 /* If we don't need this section, strip it from the
3332 output file. This is mostly to handle .rel.bss and
3333 .rel.plt. We must create both sections in
3334 create_dynamic_sections, because they must be created
3335 before the linker maps input sections to output
3336 sections. The linker does that before
3337 adjust_dynamic_symbol is called, and it is that
3338 function which decides whether anything needs to go
3339 into these sections. */
3341 s
->flags
|= SEC_EXCLUDE
;
3345 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3348 /* Allocate memory for the section contents. We use bfd_zalloc
3349 here in case unused entries are not reclaimed before the
3350 section's contents are written out. This should not happen,
3351 but this way if it does, we get a R_386_NONE reloc instead
3353 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3354 if (s
->contents
== NULL
)
3358 if (htab
->plt_eh_frame
!= NULL
3359 && htab
->plt_eh_frame
->contents
!= NULL
)
3361 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3362 sizeof (elf_i386_eh_frame_plt
));
3363 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3364 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3367 if (htab
->elf
.dynamic_sections_created
)
3369 /* Add some entries to the .dynamic section. We fill in the
3370 values later, in elf_i386_finish_dynamic_sections, but we
3371 must add the entries now so that we get the correct size for
3372 the .dynamic section. The DT_DEBUG entry is filled in by the
3373 dynamic linker and used by the debugger. */
3374 #define add_dynamic_entry(TAG, VAL) \
3375 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3377 if (bfd_link_executable (info
))
3379 if (!add_dynamic_entry (DT_DEBUG
, 0))
3383 if (htab
->elf
.splt
->size
!= 0)
3385 /* DT_PLTGOT is used by prelink even if there is no PLT
3387 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3390 if (htab
->elf
.srelplt
->size
!= 0)
3392 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3393 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3394 || !add_dynamic_entry (DT_JMPREL
, 0))
3401 if (!add_dynamic_entry (DT_REL
, 0)
3402 || !add_dynamic_entry (DT_RELSZ
, 0)
3403 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3406 /* If any dynamic relocs apply to a read-only section,
3407 then we need a DT_TEXTREL entry. */
3408 if ((info
->flags
& DF_TEXTREL
) == 0)
3409 elf_link_hash_traverse (&htab
->elf
,
3410 elf_i386_readonly_dynrelocs
, info
);
3412 if ((info
->flags
& DF_TEXTREL
) != 0)
3414 if (htab
->readonly_dynrelocs_against_ifunc
)
3416 info
->callbacks
->einfo
3417 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3418 bfd_set_error (bfd_error_bad_value
);
3422 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3426 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3427 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3430 #undef add_dynamic_entry
3436 elf_i386_always_size_sections (bfd
*output_bfd
,
3437 struct bfd_link_info
*info
)
3439 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3443 struct elf_link_hash_entry
*tlsbase
;
3445 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3446 "_TLS_MODULE_BASE_",
3447 FALSE
, FALSE
, FALSE
);
3449 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3451 struct elf_i386_link_hash_table
*htab
;
3452 struct bfd_link_hash_entry
*bh
= NULL
;
3453 const struct elf_backend_data
*bed
3454 = get_elf_backend_data (output_bfd
);
3456 htab
= elf_i386_hash_table (info
);
3460 if (!(_bfd_generic_link_add_one_symbol
3461 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3462 tls_sec
, 0, NULL
, FALSE
,
3463 bed
->collect
, &bh
)))
3466 htab
->tls_module_base
= bh
;
3468 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3469 tlsbase
->def_regular
= 1;
3470 tlsbase
->other
= STV_HIDDEN
;
3471 tlsbase
->root
.linker_def
= 1;
3472 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3479 /* Set the correct type for an x86 ELF section. We do this by the
3480 section name, which is a hack, but ought to work. */
3483 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3484 Elf_Internal_Shdr
*hdr
,
3489 name
= bfd_get_section_name (abfd
, sec
);
3491 /* This is an ugly, but unfortunately necessary hack that is
3492 needed when producing EFI binaries on x86. It tells
3493 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3494 containing ELF relocation info. We need this hack in order to
3495 be able to generate ELF binaries that can be translated into
3496 EFI applications (which are essentially COFF objects). Those
3497 files contain a COFF ".reloc" section inside an ELFNN object,
3498 which would normally cause BFD to segfault because it would
3499 attempt to interpret this section as containing relocation
3500 entries for section "oc". With this hack enabled, ".reloc"
3501 will be treated as a normal data section, which will avoid the
3502 segfault. However, you won't be able to create an ELFNN binary
3503 with a section named "oc" that needs relocations, but that's
3504 the kind of ugly side-effects you get when detecting section
3505 types based on their names... In practice, this limitation is
3506 unlikely to bite. */
3507 if (strcmp (name
, ".reloc") == 0)
3508 hdr
->sh_type
= SHT_PROGBITS
;
3513 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3514 executables. Rather than setting it to the beginning of the TLS
3515 section, we have to set it to the end. This function may be called
3516 multiple times, it is idempotent. */
3519 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3521 struct elf_i386_link_hash_table
*htab
;
3522 struct bfd_link_hash_entry
*base
;
3524 if (!bfd_link_executable (info
))
3527 htab
= elf_i386_hash_table (info
);
3531 base
= htab
->tls_module_base
;
3535 base
->u
.def
.value
= htab
->elf
.tls_size
;
3538 /* Return the base VMA address which should be subtracted from real addresses
3539 when resolving @dtpoff relocation.
3540 This is PT_TLS segment p_vaddr. */
3543 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3545 /* If tls_sec is NULL, we should have signalled an error already. */
3546 if (elf_hash_table (info
)->tls_sec
== NULL
)
3548 return elf_hash_table (info
)->tls_sec
->vma
;
3551 /* Return the relocation value for @tpoff relocation
3552 if STT_TLS virtual address is ADDRESS. */
3555 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3557 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3558 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3559 bfd_vma static_tls_size
;
3561 /* If tls_sec is NULL, we should have signalled an error already. */
3562 if (htab
->tls_sec
== NULL
)
3565 /* Consider special static TLS alignment requirements. */
3566 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3567 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3570 /* Relocate an i386 ELF section. */
3573 elf_i386_relocate_section (bfd
*output_bfd
,
3574 struct bfd_link_info
*info
,
3576 asection
*input_section
,
3578 Elf_Internal_Rela
*relocs
,
3579 Elf_Internal_Sym
*local_syms
,
3580 asection
**local_sections
)
3582 struct elf_i386_link_hash_table
*htab
;
3583 Elf_Internal_Shdr
*symtab_hdr
;
3584 struct elf_link_hash_entry
**sym_hashes
;
3585 bfd_vma
*local_got_offsets
;
3586 bfd_vma
*local_tlsdesc_gotents
;
3587 Elf_Internal_Rela
*rel
;
3588 Elf_Internal_Rela
*wrel
;
3589 Elf_Internal_Rela
*relend
;
3590 bfd_boolean is_vxworks_tls
;
3591 unsigned plt_entry_size
;
3593 BFD_ASSERT (is_i386_elf (input_bfd
));
3595 /* Skip if check_relocs failed. */
3596 if (input_section
->check_relocs_failed
)
3599 htab
= elf_i386_hash_table (info
);
3602 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3603 sym_hashes
= elf_sym_hashes (input_bfd
);
3604 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3605 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3606 /* We have to handle relocations in vxworks .tls_vars sections
3607 specially, because the dynamic loader is 'weird'. */
3608 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3609 && bfd_link_pic (info
)
3610 && !strcmp (input_section
->output_section
->name
,
3613 elf_i386_set_tls_module_base (info
);
3615 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3617 rel
= wrel
= relocs
;
3618 relend
= relocs
+ input_section
->reloc_count
;
3619 for (; rel
< relend
; wrel
++, rel
++)
3621 unsigned int r_type
;
3622 reloc_howto_type
*howto
;
3623 unsigned long r_symndx
;
3624 struct elf_link_hash_entry
*h
;
3625 struct elf_i386_link_hash_entry
*eh
;
3626 Elf_Internal_Sym
*sym
;
3628 bfd_vma off
, offplt
, plt_offset
;
3630 bfd_boolean unresolved_reloc
;
3631 bfd_reloc_status_type r
;
3635 asection
*resolved_plt
;
3636 bfd_boolean resolved_to_zero
;
3638 r_type
= ELF32_R_TYPE (rel
->r_info
);
3639 if (r_type
== R_386_GNU_VTINHERIT
3640 || r_type
== R_386_GNU_VTENTRY
)
3647 if ((indx
= r_type
) >= R_386_standard
3648 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3649 >= R_386_ext
- R_386_standard
)
3650 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3651 >= R_386_ext2
- R_386_ext
))
3653 (*_bfd_error_handler
)
3654 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3655 input_bfd
, input_section
, r_type
);
3656 bfd_set_error (bfd_error_bad_value
);
3659 howto
= elf_howto_table
+ indx
;
3661 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3665 unresolved_reloc
= FALSE
;
3666 if (r_symndx
< symtab_hdr
->sh_info
)
3668 sym
= local_syms
+ r_symndx
;
3669 sec
= local_sections
[r_symndx
];
3670 relocation
= (sec
->output_section
->vma
3671 + sec
->output_offset
3673 st_size
= sym
->st_size
;
3675 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3676 && ((sec
->flags
& SEC_MERGE
) != 0
3677 || (bfd_link_relocatable (info
)
3678 && sec
->output_offset
!= 0)))
3681 bfd_byte
*where
= contents
+ rel
->r_offset
;
3683 switch (howto
->size
)
3686 addend
= bfd_get_8 (input_bfd
, where
);
3687 if (howto
->pc_relative
)
3689 addend
= (addend
^ 0x80) - 0x80;
3694 addend
= bfd_get_16 (input_bfd
, where
);
3695 if (howto
->pc_relative
)
3697 addend
= (addend
^ 0x8000) - 0x8000;
3702 addend
= bfd_get_32 (input_bfd
, where
);
3703 if (howto
->pc_relative
)
3705 addend
= (addend
^ 0x80000000) - 0x80000000;
3713 if (bfd_link_relocatable (info
))
3714 addend
+= sec
->output_offset
;
3717 asection
*msec
= sec
;
3718 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3720 addend
-= relocation
;
3721 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3724 switch (howto
->size
)
3727 /* FIXME: overflow checks. */
3728 if (howto
->pc_relative
)
3730 bfd_put_8 (input_bfd
, addend
, where
);
3733 if (howto
->pc_relative
)
3735 bfd_put_16 (input_bfd
, addend
, where
);
3738 if (howto
->pc_relative
)
3740 bfd_put_32 (input_bfd
, addend
, where
);
3744 else if (!bfd_link_relocatable (info
)
3745 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3747 /* Relocate against local STT_GNU_IFUNC symbol. */
3748 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3753 /* Set STT_GNU_IFUNC symbol value. */
3754 h
->root
.u
.def
.value
= sym
->st_value
;
3755 h
->root
.u
.def
.section
= sec
;
3760 bfd_boolean warned ATTRIBUTE_UNUSED
;
3761 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3763 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3764 r_symndx
, symtab_hdr
, sym_hashes
,
3766 unresolved_reloc
, warned
, ignored
);
3770 if (sec
!= NULL
&& discarded_section (sec
))
3772 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3773 contents
+ rel
->r_offset
);
3774 wrel
->r_offset
= rel
->r_offset
;
3778 /* For ld -r, remove relocations in debug sections against
3779 sections defined in discarded sections. Not done for
3780 eh_frame editing code expects to be present. */
3781 if (bfd_link_relocatable (info
)
3782 && (input_section
->flags
& SEC_DEBUGGING
))
3788 if (bfd_link_relocatable (info
))
3795 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3796 it here if it is defined in a non-shared object. */
3798 && h
->type
== STT_GNU_IFUNC
3801 asection
*plt
, *gotplt
, *base_got
;
3805 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3807 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3808 sections because such sections are not SEC_ALLOC and
3809 thus ld.so will not process them. */
3810 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3814 else if (h
->plt
.offset
== (bfd_vma
) -1)
3817 /* STT_GNU_IFUNC symbol must go through PLT. */
3818 if (htab
->elf
.splt
!= NULL
)
3820 plt
= htab
->elf
.splt
;
3821 gotplt
= htab
->elf
.sgotplt
;
3825 plt
= htab
->elf
.iplt
;
3826 gotplt
= htab
->elf
.igotplt
;
3829 relocation
= (plt
->output_section
->vma
3830 + plt
->output_offset
+ h
->plt
.offset
);
3835 if (h
->root
.root
.string
)
3836 name
= h
->root
.root
.string
;
3838 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3840 (*_bfd_error_handler
)
3841 (_("%B: relocation %s against STT_GNU_IFUNC "
3842 "symbol `%s' isn't handled by %s"), input_bfd
,
3843 elf_howto_table
[r_type
].name
,
3844 name
, __FUNCTION__
);
3845 bfd_set_error (bfd_error_bad_value
);
3849 /* Generate dynamic relcoation only when there is a
3850 non-GOT reference in a shared object. */
3851 if (bfd_link_pic (info
) && h
->non_got_ref
)
3853 Elf_Internal_Rela outrel
;
3857 /* Need a dynamic relocation to get the real function
3859 offset
= _bfd_elf_section_offset (output_bfd
,
3863 if (offset
== (bfd_vma
) -1
3864 || offset
== (bfd_vma
) -2)
3867 outrel
.r_offset
= (input_section
->output_section
->vma
3868 + input_section
->output_offset
3871 if (h
->dynindx
== -1
3873 || bfd_link_executable (info
))
3875 /* This symbol is resolved locally. */
3876 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
3877 bfd_put_32 (output_bfd
,
3878 (h
->root
.u
.def
.value
3879 + h
->root
.u
.def
.section
->output_section
->vma
3880 + h
->root
.u
.def
.section
->output_offset
),
3884 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
3886 sreloc
= htab
->elf
.irelifunc
;
3887 elf_append_rel (output_bfd
, sreloc
, &outrel
);
3889 /* If this reloc is against an external symbol, we
3890 do not want to fiddle with the addend. Otherwise,
3891 we need to include the symbol value so that it
3892 becomes an addend for the dynamic reloc. For an
3893 internal symbol, we have updated addend. */
3903 base_got
= htab
->elf
.sgot
;
3904 off
= h
->got
.offset
;
3906 if (base_got
== NULL
)
3909 if (off
== (bfd_vma
) -1)
3911 /* We can't use h->got.offset here to save state, or
3912 even just remember the offset, as finish_dynamic_symbol
3913 would use that as offset into .got. */
3915 if (htab
->elf
.splt
!= NULL
)
3917 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3918 off
= (plt_index
+ 3) * 4;
3919 base_got
= htab
->elf
.sgotplt
;
3923 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3924 off
= plt_index
* 4;
3925 base_got
= htab
->elf
.igotplt
;
3928 if (h
->dynindx
== -1
3932 /* This references the local defitionion. We must
3933 initialize this entry in the global offset table.
3934 Since the offset must always be a multiple of 8,
3935 we use the least significant bit to record
3936 whether we have initialized it already.
3938 When doing a dynamic link, we create a .rela.got
3939 relocation entry to initialize the value. This
3940 is done in the finish_dynamic_symbol routine. */
3945 bfd_put_32 (output_bfd
, relocation
,
3946 base_got
->contents
+ off
);
3953 /* Adjust for static executables. */
3954 if (htab
->elf
.splt
== NULL
)
3955 relocation
+= gotplt
->output_offset
;
3959 relocation
= (base_got
->output_section
->vma
3960 + base_got
->output_offset
+ off
3961 - gotplt
->output_section
->vma
3962 - gotplt
->output_offset
);
3963 /* Adjust for static executables. */
3964 if (htab
->elf
.splt
== NULL
)
3965 relocation
+= gotplt
->output_offset
;
3971 relocation
-= (gotplt
->output_section
->vma
3972 + gotplt
->output_offset
);
3977 eh
= (struct elf_i386_link_hash_entry
*) h
;
3978 resolved_to_zero
= (eh
!= NULL
3979 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3986 /* Avoid optimizing _DYNAMIC since ld.so may use its
3987 link-time address. */
3988 if (h
== htab
->elf
.hdynamic
)
3991 if (bfd_link_pic (info
))
3993 /* It is OK to convert mov to lea and convert indirect
3994 branch to direct branch. It is OK to convert adc,
3995 add, and, cmp, or, sbb, sub, test, xor only when PIC
3997 unsigned int opcode
, addend
;
3998 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4001 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4002 if (opcode
!= 0x8b && opcode
!= 0xff)
4006 /* Resolve "mov GOT[(%reg)], %reg",
4007 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4008 and "binop foo@GOT[(%reg)], %reg". */
4010 || (h
->plt
.offset
== (bfd_vma
) -1
4011 && h
->got
.offset
== (bfd_vma
) -1)
4012 || htab
->elf
.sgotplt
== NULL
)
4015 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4016 + htab
->elf
.sgotplt
->output_offset
);
4018 /* It is relative to .got.plt section. */
4019 if (h
->got
.offset
!= (bfd_vma
) -1)
4020 /* Use GOT entry. Mask off the least significant bit in
4021 GOT offset which may be set by R_386_GOT32 processing
4023 relocation
= (htab
->elf
.sgot
->output_section
->vma
4024 + htab
->elf
.sgot
->output_offset
4025 + (h
->got
.offset
& ~1) - offplt
);
4027 /* Use GOTPLT entry. */
4028 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4030 if (!bfd_link_pic (info
))
4032 /* If not PIC, add the .got.plt section address for
4033 baseless addressing. */
4035 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4036 if ((modrm
& 0xc7) == 0x5)
4037 relocation
+= offplt
;
4040 unresolved_reloc
= FALSE
;
4045 /* Relocation is to the entry for this symbol in the global
4047 if (htab
->elf
.sgot
== NULL
)
4054 off
= h
->got
.offset
;
4055 dyn
= htab
->elf
.dynamic_sections_created
;
4056 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4057 bfd_link_pic (info
),
4059 || (bfd_link_pic (info
)
4060 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4061 || (ELF_ST_VISIBILITY (h
->other
)
4062 && h
->root
.type
== bfd_link_hash_undefweak
))
4064 /* This is actually a static link, or it is a
4065 -Bsymbolic link and the symbol is defined
4066 locally, or the symbol was forced to be local
4067 because of a version file. We must initialize
4068 this entry in the global offset table. Since the
4069 offset must always be a multiple of 4, we use the
4070 least significant bit to record whether we have
4071 initialized it already.
4073 When doing a dynamic link, we create a .rel.got
4074 relocation entry to initialize the value. This
4075 is done in the finish_dynamic_symbol routine. */
4080 bfd_put_32 (output_bfd
, relocation
,
4081 htab
->elf
.sgot
->contents
+ off
);
4086 unresolved_reloc
= FALSE
;
4090 if (local_got_offsets
== NULL
)
4093 off
= local_got_offsets
[r_symndx
];
4095 /* The offset must always be a multiple of 4. We use
4096 the least significant bit to record whether we have
4097 already generated the necessary reloc. */
4102 bfd_put_32 (output_bfd
, relocation
,
4103 htab
->elf
.sgot
->contents
+ off
);
4105 if (bfd_link_pic (info
))
4108 Elf_Internal_Rela outrel
;
4110 s
= htab
->elf
.srelgot
;
4114 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4115 + htab
->elf
.sgot
->output_offset
4117 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4118 elf_append_rel (output_bfd
, s
, &outrel
);
4121 local_got_offsets
[r_symndx
] |= 1;
4125 if (off
>= (bfd_vma
) -2)
4128 relocation
= htab
->elf
.sgot
->output_section
->vma
4129 + htab
->elf
.sgot
->output_offset
+ off
4130 - htab
->elf
.sgotplt
->output_section
->vma
4131 - htab
->elf
.sgotplt
->output_offset
;
4135 /* Relocation is relative to the start of the global offset
4138 /* Check to make sure it isn't a protected function or data
4139 symbol for shared library since it may not be local when
4140 used as function address or with copy relocation. We also
4141 need to make sure that a symbol is referenced locally. */
4142 if (!bfd_link_executable (info
) && h
)
4144 if (!h
->def_regular
)
4148 switch (ELF_ST_VISIBILITY (h
->other
))
4151 v
= _("hidden symbol");
4154 v
= _("internal symbol");
4157 v
= _("protected symbol");
4164 (*_bfd_error_handler
)
4165 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4166 input_bfd
, v
, h
->root
.root
.string
);
4167 bfd_set_error (bfd_error_bad_value
);
4170 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4171 && (h
->type
== STT_FUNC
4172 || h
->type
== STT_OBJECT
)
4173 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4175 (*_bfd_error_handler
)
4176 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4178 h
->type
== STT_FUNC
? "function" : "data",
4179 h
->root
.root
.string
);
4180 bfd_set_error (bfd_error_bad_value
);
4185 /* Note that sgot is not involved in this
4186 calculation. We always want the start of .got.plt. If we
4187 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4188 permitted by the ABI, we might have to change this
4190 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4191 + htab
->elf
.sgotplt
->output_offset
;
4195 /* Use global offset table as symbol value. */
4196 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4197 + htab
->elf
.sgotplt
->output_offset
;
4198 unresolved_reloc
= FALSE
;
4202 /* Relocation is to the entry for this symbol in the
4203 procedure linkage table. */
4205 /* Resolve a PLT32 reloc against a local symbol directly,
4206 without using the procedure linkage table. */
4210 if ((h
->plt
.offset
== (bfd_vma
) -1
4211 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4212 || htab
->elf
.splt
== NULL
)
4214 /* We didn't make a PLT entry for this symbol. This
4215 happens when statically linking PIC code, or when
4216 using -Bsymbolic. */
4220 if (h
->plt
.offset
!= (bfd_vma
) -1)
4222 resolved_plt
= htab
->elf
.splt
;
4223 plt_offset
= h
->plt
.offset
;
4227 resolved_plt
= htab
->plt_got
;
4228 plt_offset
= eh
->plt_got
.offset
;
4231 relocation
= (resolved_plt
->output_section
->vma
4232 + resolved_plt
->output_offset
4234 unresolved_reloc
= FALSE
;
4238 /* Set to symbol size. */
4239 relocation
= st_size
;
4244 if ((input_section
->flags
& SEC_ALLOC
) == 0
4248 /* Copy dynamic function pointer relocations. Don't generate
4249 dynamic relocations against resolved undefined weak symbols
4250 in PIE, except for R_386_PC32. */
4251 if ((bfd_link_pic (info
)
4253 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4254 && (!resolved_to_zero
4255 || r_type
== R_386_PC32
))
4256 || h
->root
.type
!= bfd_link_hash_undefweak
))
4257 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4258 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4259 || (ELIMINATE_COPY_RELOCS
4260 && !bfd_link_pic (info
)
4264 || eh
->func_pointer_refcount
> 0
4265 || (h
->root
.type
== bfd_link_hash_undefweak
4266 && !resolved_to_zero
))
4267 && ((h
->def_dynamic
&& !h
->def_regular
)
4268 /* Undefined weak symbol is bound locally when
4270 || h
->root
.type
== bfd_link_hash_undefweak
)))
4272 Elf_Internal_Rela outrel
;
4273 bfd_boolean skip
, relocate
;
4276 /* When generating a shared object, these relocations
4277 are copied into the output file to be resolved at run
4284 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4286 if (outrel
.r_offset
== (bfd_vma
) -1)
4288 else if (outrel
.r_offset
== (bfd_vma
) -2)
4289 skip
= TRUE
, relocate
= TRUE
;
4290 outrel
.r_offset
+= (input_section
->output_section
->vma
4291 + input_section
->output_offset
);
4294 memset (&outrel
, 0, sizeof outrel
);
4297 && (r_type
== R_386_PC32
4298 || !(bfd_link_executable (info
)
4299 || SYMBOLIC_BIND (info
, h
))
4300 || !h
->def_regular
))
4301 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4304 /* This symbol is local, or marked to become local. */
4306 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4309 sreloc
= elf_section_data (input_section
)->sreloc
;
4311 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4313 r
= bfd_reloc_notsupported
;
4314 goto check_relocation_error
;
4317 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4319 /* If this reloc is against an external symbol, we do
4320 not want to fiddle with the addend. Otherwise, we
4321 need to include the symbol value so that it becomes
4322 an addend for the dynamic reloc. */
4329 if (!bfd_link_executable (info
))
4331 Elf_Internal_Rela outrel
;
4334 outrel
.r_offset
= rel
->r_offset
4335 + input_section
->output_section
->vma
4336 + input_section
->output_offset
;
4337 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4338 sreloc
= elf_section_data (input_section
)->sreloc
;
4341 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4346 case R_386_TLS_GOTDESC
:
4347 case R_386_TLS_DESC_CALL
:
4348 case R_386_TLS_IE_32
:
4349 case R_386_TLS_GOTIE
:
4350 tls_type
= GOT_UNKNOWN
;
4351 if (h
== NULL
&& local_got_offsets
)
4352 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4354 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4355 if (tls_type
== GOT_TLS_IE
)
4356 tls_type
= GOT_TLS_IE_NEG
;
4358 if (! elf_i386_tls_transition (info
, input_bfd
,
4359 input_section
, contents
,
4360 symtab_hdr
, sym_hashes
,
4361 &r_type
, tls_type
, rel
,
4362 relend
, h
, r_symndx
))
4365 if (r_type
== R_386_TLS_LE_32
)
4367 BFD_ASSERT (! unresolved_reloc
);
4368 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4373 /* GD->LE transition. */
4374 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4377 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4379 movl %gs:0, %eax; subl $foo@tpoff, %eax
4380 (6 byte form of subl). */
4381 memcpy (contents
+ rel
->r_offset
- 3,
4382 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4383 roff
= rel
->r_offset
+ 5;
4387 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4389 movl %gs:0, %eax; subl $foo@tpoff, %eax
4390 (6 byte form of subl). */
4391 memcpy (contents
+ rel
->r_offset
- 2,
4392 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4393 roff
= rel
->r_offset
+ 6;
4395 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4397 /* Skip R_386_PC32/R_386_PLT32. */
4402 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4404 /* GDesc -> LE transition.
4405 It's originally something like:
4406 leal x@tlsdesc(%ebx), %eax
4410 Registers other than %eax may be set up here. */
4415 roff
= rel
->r_offset
;
4416 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4418 /* Now modify the instruction as appropriate. */
4419 /* aoliva FIXME: remove the above and xor the byte
4421 bfd_put_8 (output_bfd
, val
^ 0x86,
4422 contents
+ roff
- 1);
4423 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4427 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4429 /* GDesc -> LE transition.
4437 roff
= rel
->r_offset
;
4438 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4439 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4442 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4446 /* IE->LE transition:
4447 Originally it can be one of:
4455 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4458 /* movl foo, %eax. */
4459 bfd_put_8 (output_bfd
, 0xb8,
4460 contents
+ rel
->r_offset
- 1);
4466 type
= bfd_get_8 (input_bfd
,
4467 contents
+ rel
->r_offset
- 2);
4472 bfd_put_8 (output_bfd
, 0xc7,
4473 contents
+ rel
->r_offset
- 2);
4474 bfd_put_8 (output_bfd
,
4475 0xc0 | ((val
>> 3) & 7),
4476 contents
+ rel
->r_offset
- 1);
4480 bfd_put_8 (output_bfd
, 0x81,
4481 contents
+ rel
->r_offset
- 2);
4482 bfd_put_8 (output_bfd
,
4483 0xc0 | ((val
>> 3) & 7),
4484 contents
+ rel
->r_offset
- 1);
4491 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4492 contents
+ rel
->r_offset
);
4497 unsigned int val
, type
;
4499 /* {IE_32,GOTIE}->LE transition:
4500 Originally it can be one of:
4501 subl foo(%reg1), %reg2
4502 movl foo(%reg1), %reg2
4503 addl foo(%reg1), %reg2
4506 movl $foo, %reg2 (6 byte form)
4507 addl $foo, %reg2. */
4508 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4509 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4513 bfd_put_8 (output_bfd
, 0xc7,
4514 contents
+ rel
->r_offset
- 2);
4515 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4516 contents
+ rel
->r_offset
- 1);
4518 else if (type
== 0x2b)
4521 bfd_put_8 (output_bfd
, 0x81,
4522 contents
+ rel
->r_offset
- 2);
4523 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4524 contents
+ rel
->r_offset
- 1);
4526 else if (type
== 0x03)
4529 bfd_put_8 (output_bfd
, 0x81,
4530 contents
+ rel
->r_offset
- 2);
4531 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4532 contents
+ rel
->r_offset
- 1);
4536 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4537 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4538 contents
+ rel
->r_offset
);
4540 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4541 contents
+ rel
->r_offset
);
4546 if (htab
->elf
.sgot
== NULL
)
4551 off
= h
->got
.offset
;
4552 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4556 if (local_got_offsets
== NULL
)
4559 off
= local_got_offsets
[r_symndx
];
4560 offplt
= local_tlsdesc_gotents
[r_symndx
];
4567 Elf_Internal_Rela outrel
;
4571 if (htab
->elf
.srelgot
== NULL
)
4574 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4576 if (GOT_TLS_GDESC_P (tls_type
))
4579 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4580 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4581 <= htab
->elf
.sgotplt
->size
);
4582 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4583 + htab
->elf
.sgotplt
->output_offset
4585 + htab
->sgotplt_jump_table_size
);
4586 sreloc
= htab
->elf
.srelplt
;
4587 loc
= sreloc
->contents
;
4588 loc
+= (htab
->next_tls_desc_index
++
4589 * sizeof (Elf32_External_Rel
));
4590 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4591 <= sreloc
->contents
+ sreloc
->size
);
4592 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4595 BFD_ASSERT (! unresolved_reloc
);
4596 bfd_put_32 (output_bfd
,
4597 relocation
- elf_i386_dtpoff_base (info
),
4598 htab
->elf
.sgotplt
->contents
+ offplt
4599 + htab
->sgotplt_jump_table_size
+ 4);
4603 bfd_put_32 (output_bfd
, 0,
4604 htab
->elf
.sgotplt
->contents
+ offplt
4605 + htab
->sgotplt_jump_table_size
+ 4);
4609 sreloc
= htab
->elf
.srelgot
;
4611 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4612 + htab
->elf
.sgot
->output_offset
+ off
);
4614 if (GOT_TLS_GD_P (tls_type
))
4615 dr_type
= R_386_TLS_DTPMOD32
;
4616 else if (GOT_TLS_GDESC_P (tls_type
))
4618 else if (tls_type
== GOT_TLS_IE_POS
)
4619 dr_type
= R_386_TLS_TPOFF
;
4621 dr_type
= R_386_TLS_TPOFF32
;
4623 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4624 bfd_put_32 (output_bfd
,
4625 relocation
- elf_i386_dtpoff_base (info
),
4626 htab
->elf
.sgot
->contents
+ off
);
4627 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4628 bfd_put_32 (output_bfd
,
4629 elf_i386_dtpoff_base (info
) - relocation
,
4630 htab
->elf
.sgot
->contents
+ off
);
4631 else if (dr_type
!= R_386_TLS_DESC
)
4632 bfd_put_32 (output_bfd
, 0,
4633 htab
->elf
.sgot
->contents
+ off
);
4634 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4636 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4638 if (GOT_TLS_GD_P (tls_type
))
4642 BFD_ASSERT (! unresolved_reloc
);
4643 bfd_put_32 (output_bfd
,
4644 relocation
- elf_i386_dtpoff_base (info
),
4645 htab
->elf
.sgot
->contents
+ off
+ 4);
4649 bfd_put_32 (output_bfd
, 0,
4650 htab
->elf
.sgot
->contents
+ off
+ 4);
4651 outrel
.r_info
= ELF32_R_INFO (indx
,
4652 R_386_TLS_DTPOFF32
);
4653 outrel
.r_offset
+= 4;
4654 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4657 else if (tls_type
== GOT_TLS_IE_BOTH
)
4659 bfd_put_32 (output_bfd
,
4661 ? relocation
- elf_i386_dtpoff_base (info
)
4663 htab
->elf
.sgot
->contents
+ off
+ 4);
4664 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4665 outrel
.r_offset
+= 4;
4666 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4673 local_got_offsets
[r_symndx
] |= 1;
4676 if (off
>= (bfd_vma
) -2
4677 && ! GOT_TLS_GDESC_P (tls_type
))
4679 if (r_type
== R_386_TLS_GOTDESC
4680 || r_type
== R_386_TLS_DESC_CALL
)
4682 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4683 unresolved_reloc
= FALSE
;
4685 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4687 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4688 + htab
->elf
.sgotplt
->output_offset
;
4689 relocation
= htab
->elf
.sgot
->output_section
->vma
4690 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4691 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4692 && tls_type
== GOT_TLS_IE_BOTH
)
4694 if (r_type
== R_386_TLS_IE
)
4695 relocation
+= g_o_t
;
4696 unresolved_reloc
= FALSE
;
4698 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4700 unsigned int val
, type
;
4703 /* GD->IE transition. */
4704 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4705 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4708 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4710 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4712 roff
= rel
->r_offset
- 3;
4716 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4718 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4719 roff
= rel
->r_offset
- 2;
4721 memcpy (contents
+ roff
,
4722 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4723 contents
[roff
+ 7] = 0x80 | (val
& 7);
4724 /* If foo is used only with foo@gotntpoff(%reg) and
4725 foo@indntpoff, but not with foo@gottpoff(%reg), change
4726 subl $foo@gottpoff(%reg), %eax
4728 addl $foo@gotntpoff(%reg), %eax. */
4729 if (tls_type
== GOT_TLS_IE_POS
)
4730 contents
[roff
+ 6] = 0x03;
4731 bfd_put_32 (output_bfd
,
4732 htab
->elf
.sgot
->output_section
->vma
4733 + htab
->elf
.sgot
->output_offset
+ off
4734 - htab
->elf
.sgotplt
->output_section
->vma
4735 - htab
->elf
.sgotplt
->output_offset
,
4736 contents
+ roff
+ 8);
4737 /* Skip R_386_PLT32. */
4742 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4744 /* GDesc -> IE transition.
4745 It's originally something like:
4746 leal x@tlsdesc(%ebx), %eax
4749 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4751 movl x@gottpoff(%ebx), %eax # before negl %eax
4753 Registers other than %eax may be set up here. */
4757 /* First, make sure it's a leal adding ebx to a 32-bit
4758 offset into any register, although it's probably
4759 almost always going to be eax. */
4760 roff
= rel
->r_offset
;
4762 /* Now modify the instruction as appropriate. */
4763 /* To turn a leal into a movl in the form we use it, it
4764 suffices to change the first byte from 0x8d to 0x8b.
4765 aoliva FIXME: should we decide to keep the leal, all
4766 we have to do is remove the statement below, and
4767 adjust the relaxation of R_386_TLS_DESC_CALL. */
4768 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4770 if (tls_type
== GOT_TLS_IE_BOTH
)
4773 bfd_put_32 (output_bfd
,
4774 htab
->elf
.sgot
->output_section
->vma
4775 + htab
->elf
.sgot
->output_offset
+ off
4776 - htab
->elf
.sgotplt
->output_section
->vma
4777 - htab
->elf
.sgotplt
->output_offset
,
4781 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4783 /* GDesc -> IE transition.
4791 depending on how we transformed the TLS_GOTDESC above.
4796 roff
= rel
->r_offset
;
4798 /* Now modify the instruction as appropriate. */
4799 if (tls_type
!= GOT_TLS_IE_NEG
)
4802 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4803 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4808 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
4809 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
4819 if (! elf_i386_tls_transition (info
, input_bfd
,
4820 input_section
, contents
,
4821 symtab_hdr
, sym_hashes
,
4822 &r_type
, GOT_UNKNOWN
, rel
,
4823 relend
, h
, r_symndx
))
4826 if (r_type
!= R_386_TLS_LDM
)
4828 /* LD->LE transition:
4829 leal foo(%reg), %eax; call ___tls_get_addr.
4831 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4832 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
4833 memcpy (contents
+ rel
->r_offset
- 2,
4834 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4835 /* Skip R_386_PC32/R_386_PLT32. */
4841 if (htab
->elf
.sgot
== NULL
)
4844 off
= htab
->tls_ldm_got
.offset
;
4849 Elf_Internal_Rela outrel
;
4851 if (htab
->elf
.srelgot
== NULL
)
4854 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4855 + htab
->elf
.sgot
->output_offset
+ off
);
4857 bfd_put_32 (output_bfd
, 0,
4858 htab
->elf
.sgot
->contents
+ off
);
4859 bfd_put_32 (output_bfd
, 0,
4860 htab
->elf
.sgot
->contents
+ off
+ 4);
4861 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
4862 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
4863 htab
->tls_ldm_got
.offset
|= 1;
4865 relocation
= htab
->elf
.sgot
->output_section
->vma
4866 + htab
->elf
.sgot
->output_offset
+ off
4867 - htab
->elf
.sgotplt
->output_section
->vma
4868 - htab
->elf
.sgotplt
->output_offset
;
4869 unresolved_reloc
= FALSE
;
4872 case R_386_TLS_LDO_32
:
4873 if (!bfd_link_executable (info
)
4874 || (input_section
->flags
& SEC_CODE
) == 0)
4875 relocation
-= elf_i386_dtpoff_base (info
);
4877 /* When converting LDO to LE, we must negate. */
4878 relocation
= -elf_i386_tpoff (info
, relocation
);
4881 case R_386_TLS_LE_32
:
4883 if (!bfd_link_executable (info
))
4885 Elf_Internal_Rela outrel
;
4888 outrel
.r_offset
= rel
->r_offset
4889 + input_section
->output_section
->vma
4890 + input_section
->output_offset
;
4891 if (h
!= NULL
&& h
->dynindx
!= -1)
4895 if (r_type
== R_386_TLS_LE_32
)
4896 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
4898 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4899 sreloc
= elf_section_data (input_section
)->sreloc
;
4902 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4905 else if (r_type
== R_386_TLS_LE_32
)
4906 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
4908 relocation
-= elf_i386_dtpoff_base (info
);
4910 else if (r_type
== R_386_TLS_LE_32
)
4911 relocation
= elf_i386_tpoff (info
, relocation
);
4913 relocation
= -elf_i386_tpoff (info
, relocation
);
4920 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4921 because such sections are not SEC_ALLOC and thus ld.so will
4922 not process them. */
4923 if (unresolved_reloc
4924 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4926 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4927 rel
->r_offset
) != (bfd_vma
) -1)
4929 (*_bfd_error_handler
)
4930 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4933 (long) rel
->r_offset
,
4935 h
->root
.root
.string
);
4940 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4941 contents
, rel
->r_offset
,
4944 check_relocation_error
:
4945 if (r
!= bfd_reloc_ok
)
4950 name
= h
->root
.root
.string
;
4953 name
= bfd_elf_string_from_elf_section (input_bfd
,
4954 symtab_hdr
->sh_link
,
4959 name
= bfd_section_name (input_bfd
, sec
);
4962 if (r
== bfd_reloc_overflow
)
4964 if (! ((*info
->callbacks
->reloc_overflow
)
4965 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4966 (bfd_vma
) 0, input_bfd
, input_section
,
4972 (*_bfd_error_handler
)
4973 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4974 input_bfd
, input_section
,
4975 (long) rel
->r_offset
, name
, (int) r
);
4986 Elf_Internal_Shdr
*rel_hdr
;
4987 size_t deleted
= rel
- wrel
;
4989 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4990 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4991 if (rel_hdr
->sh_size
== 0)
4993 /* It is too late to remove an empty reloc section. Leave
4995 ??? What is wrong with an empty section??? */
4996 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4999 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5000 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5001 input_section
->reloc_count
-= deleted
;
5007 /* Finish up dynamic symbol handling. We set the contents of various
5008 dynamic sections here. */
5011 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5012 struct bfd_link_info
*info
,
5013 struct elf_link_hash_entry
*h
,
5014 Elf_Internal_Sym
*sym
)
5016 struct elf_i386_link_hash_table
*htab
;
5017 unsigned plt_entry_size
;
5018 const struct elf_i386_backend_data
*abed
;
5019 struct elf_i386_link_hash_entry
*eh
;
5020 bfd_boolean local_undefweak
;
5022 htab
= elf_i386_hash_table (info
);
5026 abed
= get_elf_i386_backend_data (output_bfd
);
5027 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5029 eh
= (struct elf_i386_link_hash_entry
*) h
;
5031 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5032 resolved undefined weak symbols in executable so that their
5033 references have value 0 at run-time. */
5034 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5038 if (h
->plt
.offset
!= (bfd_vma
) -1)
5042 Elf_Internal_Rela rel
;
5044 asection
*plt
, *gotplt
, *relplt
;
5046 /* When building a static executable, use .iplt, .igot.plt and
5047 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5048 if (htab
->elf
.splt
!= NULL
)
5050 plt
= htab
->elf
.splt
;
5051 gotplt
= htab
->elf
.sgotplt
;
5052 relplt
= htab
->elf
.srelplt
;
5056 plt
= htab
->elf
.iplt
;
5057 gotplt
= htab
->elf
.igotplt
;
5058 relplt
= htab
->elf
.irelplt
;
5061 /* This symbol has an entry in the procedure linkage table. Set
5064 if ((h
->dynindx
== -1
5066 && !((h
->forced_local
|| bfd_link_executable (info
))
5068 && h
->type
== STT_GNU_IFUNC
))
5074 /* Get the index in the procedure linkage table which
5075 corresponds to this symbol. This is the index of this symbol
5076 in all the symbols for which we are making plt entries. The
5077 first entry in the procedure linkage table is reserved.
5079 Get the offset into the .got table of the entry that
5080 corresponds to this function. Each .got entry is 4 bytes.
5081 The first three are reserved.
5083 For static executables, we don't reserve anything. */
5085 if (plt
== htab
->elf
.splt
)
5087 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5088 got_offset
= (got_offset
+ 3) * 4;
5092 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5093 got_offset
= got_offset
* 4;
5096 /* Fill in the entry in the procedure linkage table. */
5097 if (! bfd_link_pic (info
))
5099 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5100 abed
->plt
->plt_entry_size
);
5101 bfd_put_32 (output_bfd
,
5102 (gotplt
->output_section
->vma
5103 + gotplt
->output_offset
5105 plt
->contents
+ h
->plt
.offset
5106 + abed
->plt
->plt_got_offset
);
5108 if (abed
->is_vxworks
)
5110 int s
, k
, reloc_index
;
5112 /* Create the R_386_32 relocation referencing the GOT
5113 for this PLT entry. */
5115 /* S: Current slot number (zero-based). */
5116 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5117 / abed
->plt
->plt_entry_size
);
5118 /* K: Number of relocations for PLTResolve. */
5119 if (bfd_link_pic (info
))
5120 k
= PLTRESOLVE_RELOCS_SHLIB
;
5122 k
= PLTRESOLVE_RELOCS
;
5123 /* Skip the PLTresolve relocations, and the relocations for
5124 the other PLT slots. */
5125 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5126 loc
= (htab
->srelplt2
->contents
+ reloc_index
5127 * sizeof (Elf32_External_Rel
));
5129 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5130 + htab
->elf
.splt
->output_offset
5131 + h
->plt
.offset
+ 2),
5132 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5133 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5135 /* Create the R_386_32 relocation referencing the beginning of
5136 the PLT for this GOT entry. */
5137 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5138 + htab
->elf
.sgotplt
->output_offset
5140 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5141 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5142 loc
+ sizeof (Elf32_External_Rel
));
5147 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5148 abed
->plt
->plt_entry_size
);
5149 bfd_put_32 (output_bfd
, got_offset
,
5150 plt
->contents
+ h
->plt
.offset
5151 + abed
->plt
->plt_got_offset
);
5154 /* Fill in the entry in the global offset table. Leave the entry
5155 as zero for undefined weak symbol in PIE. No PLT relocation
5156 against undefined weak symbol in PIE. */
5157 if (!local_undefweak
)
5159 bfd_put_32 (output_bfd
,
5160 (plt
->output_section
->vma
5161 + plt
->output_offset
5163 + abed
->plt
->plt_lazy_offset
),
5164 gotplt
->contents
+ got_offset
);
5166 /* Fill in the entry in the .rel.plt section. */
5167 rel
.r_offset
= (gotplt
->output_section
->vma
5168 + gotplt
->output_offset
5170 if (h
->dynindx
== -1
5171 || ((bfd_link_executable (info
)
5172 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5174 && h
->type
== STT_GNU_IFUNC
))
5176 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5177 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5178 in the .got.plt section. */
5179 bfd_put_32 (output_bfd
,
5180 (h
->root
.u
.def
.value
5181 + h
->root
.u
.def
.section
->output_section
->vma
5182 + h
->root
.u
.def
.section
->output_offset
),
5183 gotplt
->contents
+ got_offset
);
5184 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5185 /* R_386_IRELATIVE comes last. */
5186 plt_index
= htab
->next_irelative_index
--;
5190 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5191 plt_index
= htab
->next_jump_slot_index
++;
5194 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5195 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5197 /* Don't fill PLT entry for static executables. */
5198 if (plt
== htab
->elf
.splt
)
5200 bfd_put_32 (output_bfd
,
5201 plt_index
* sizeof (Elf32_External_Rel
),
5202 plt
->contents
+ h
->plt
.offset
5203 + abed
->plt
->plt_reloc_offset
);
5204 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5205 + abed
->plt
->plt_plt_offset
+ 4),
5206 plt
->contents
+ h
->plt
.offset
5207 + abed
->plt
->plt_plt_offset
);
5211 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5213 bfd_vma got_offset
, plt_offset
;
5214 asection
*plt
, *got
, *gotplt
;
5215 const bfd_byte
*got_plt_entry
;
5217 /* Offset of displacement of the indirect jump. */
5218 bfd_vma plt_got_offset
= 2;
5220 /* Set the entry in the GOT procedure linkage table. */
5221 plt
= htab
->plt_got
;
5222 got
= htab
->elf
.sgot
;
5223 gotplt
= htab
->elf
.sgotplt
;
5224 got_offset
= h
->got
.offset
;
5226 if (got_offset
== (bfd_vma
) -1
5232 /* Fill in the entry in the GOT procedure linkage table. */
5233 if (! bfd_link_pic (info
))
5235 got_plt_entry
= elf_i386_got_plt_entry
;
5236 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5240 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5241 got_offset
+= (got
->output_section
->vma
5242 + got
->output_offset
5243 - gotplt
->output_section
->vma
5244 - gotplt
->output_offset
);
5247 plt_offset
= eh
->plt_got
.offset
;
5248 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5249 sizeof (elf_i386_got_plt_entry
));
5250 bfd_put_32 (output_bfd
, got_offset
,
5251 plt
->contents
+ plt_offset
+ plt_got_offset
);
5254 if (!local_undefweak
5256 && (h
->plt
.offset
!= (bfd_vma
) -1
5257 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5259 /* Mark the symbol as undefined, rather than as defined in
5260 the .plt section. Leave the value if there were any
5261 relocations where pointer equality matters (this is a clue
5262 for the dynamic linker, to make function pointer
5263 comparisons work between an application and shared
5264 library), otherwise set it to zero. If a function is only
5265 called from a binary, there is no need to slow down
5266 shared libraries because of that. */
5267 sym
->st_shndx
= SHN_UNDEF
;
5268 if (!h
->pointer_equality_needed
)
5272 /* Don't generate dynamic GOT relocation against undefined weak
5273 symbol in executable. */
5274 if (h
->got
.offset
!= (bfd_vma
) -1
5275 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5276 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5277 && !local_undefweak
)
5279 Elf_Internal_Rela rel
;
5281 /* This symbol has an entry in the global offset table. Set it
5284 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5287 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5288 + htab
->elf
.sgot
->output_offset
5289 + (h
->got
.offset
& ~(bfd_vma
) 1));
5291 /* If this is a static link, or it is a -Bsymbolic link and the
5292 symbol is defined locally or was forced to be local because
5293 of a version file, we just want to emit a RELATIVE reloc.
5294 The entry in the global offset table will already have been
5295 initialized in the relocate_section function. */
5297 && h
->type
== STT_GNU_IFUNC
)
5299 if (bfd_link_pic (info
))
5301 /* Generate R_386_GLOB_DAT. */
5308 if (!h
->pointer_equality_needed
)
5311 /* For non-shared object, we can't use .got.plt, which
5312 contains the real function addres if we need pointer
5313 equality. We load the GOT entry with the PLT entry. */
5314 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5315 bfd_put_32 (output_bfd
,
5316 (plt
->output_section
->vma
5317 + plt
->output_offset
+ h
->plt
.offset
),
5318 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5322 else if (bfd_link_pic (info
)
5323 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5325 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5326 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5330 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5332 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5333 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5334 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5337 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &rel
);
5342 Elf_Internal_Rela rel
;
5344 /* This symbol needs a copy reloc. Set it up. */
5346 if (h
->dynindx
== -1
5347 || (h
->root
.type
!= bfd_link_hash_defined
5348 && h
->root
.type
!= bfd_link_hash_defweak
)
5349 || htab
->srelbss
== NULL
)
5352 rel
.r_offset
= (h
->root
.u
.def
.value
5353 + h
->root
.u
.def
.section
->output_section
->vma
5354 + h
->root
.u
.def
.section
->output_offset
);
5355 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5356 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5362 /* Finish up local dynamic symbol handling. We set the contents of
5363 various dynamic sections here. */
5366 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5368 struct elf_link_hash_entry
*h
5369 = (struct elf_link_hash_entry
*) *slot
;
5370 struct bfd_link_info
*info
5371 = (struct bfd_link_info
*) inf
;
5373 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5377 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5378 here since undefined weak symbol may not be dynamic and may not be
5379 called for elf_i386_finish_dynamic_symbol. */
5382 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5385 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5386 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5388 if (h
->root
.type
!= bfd_link_hash_undefweak
5389 || h
->dynindx
!= -1)
5392 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5396 /* Used to decide how to sort relocs in an optimal manner for the
5397 dynamic linker, before writing them out. */
5399 static enum elf_reloc_type_class
5400 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5401 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5402 const Elf_Internal_Rela
*rela
)
5404 bfd
*abfd
= info
->output_bfd
;
5405 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5406 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5408 if (htab
->dynsym
!= NULL
5409 && htab
->dynsym
->contents
!= NULL
)
5411 /* Check relocation against STT_GNU_IFUNC symbol if there are
5413 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5414 Elf_Internal_Sym sym
;
5415 if (!bed
->s
->swap_symbol_in (abfd
,
5416 (htab
->dynsym
->contents
5417 + r_symndx
* sizeof (Elf32_External_Sym
)),
5421 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5422 return reloc_class_ifunc
;
5425 switch (ELF32_R_TYPE (rela
->r_info
))
5427 case R_386_RELATIVE
:
5428 return reloc_class_relative
;
5429 case R_386_JUMP_SLOT
:
5430 return reloc_class_plt
;
5432 return reloc_class_copy
;
5434 return reloc_class_normal
;
5438 /* Finish up the dynamic sections. */
5441 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5442 struct bfd_link_info
*info
)
5444 struct elf_i386_link_hash_table
*htab
;
5447 const struct elf_i386_backend_data
*abed
;
5449 htab
= elf_i386_hash_table (info
);
5453 dynobj
= htab
->elf
.dynobj
;
5454 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5455 abed
= get_elf_i386_backend_data (output_bfd
);
5457 if (htab
->elf
.dynamic_sections_created
)
5459 Elf32_External_Dyn
*dyncon
, *dynconend
;
5461 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5464 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5465 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5466 for (; dyncon
< dynconend
; dyncon
++)
5468 Elf_Internal_Dyn dyn
;
5471 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5476 if (abed
->is_vxworks
5477 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5482 s
= htab
->elf
.sgotplt
;
5483 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5487 s
= htab
->elf
.srelplt
;
5488 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5492 s
= htab
->elf
.srelplt
;
5493 dyn
.d_un
.d_val
= s
->size
;
5497 /* My reading of the SVR4 ABI indicates that the
5498 procedure linkage table relocs (DT_JMPREL) should be
5499 included in the overall relocs (DT_REL). This is
5500 what Solaris does. However, UnixWare can not handle
5501 that case. Therefore, we override the DT_RELSZ entry
5502 here to make it not include the JMPREL relocs. */
5503 s
= htab
->elf
.srelplt
;
5506 dyn
.d_un
.d_val
-= s
->size
;
5510 /* We may not be using the standard ELF linker script.
5511 If .rel.plt is the first .rel section, we adjust
5512 DT_REL to not include it. */
5513 s
= htab
->elf
.srelplt
;
5516 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5518 dyn
.d_un
.d_ptr
+= s
->size
;
5522 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5525 /* Fill in the first entry in the procedure linkage table. */
5526 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5528 if (bfd_link_pic (info
))
5530 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5531 abed
->plt
->plt0_entry_size
);
5532 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5533 abed
->plt0_pad_byte
,
5534 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5538 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5539 abed
->plt
->plt0_entry_size
);
5540 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5541 abed
->plt0_pad_byte
,
5542 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5543 bfd_put_32 (output_bfd
,
5544 (htab
->elf
.sgotplt
->output_section
->vma
5545 + htab
->elf
.sgotplt
->output_offset
5547 htab
->elf
.splt
->contents
5548 + abed
->plt
->plt0_got1_offset
);
5549 bfd_put_32 (output_bfd
,
5550 (htab
->elf
.sgotplt
->output_section
->vma
5551 + htab
->elf
.sgotplt
->output_offset
5553 htab
->elf
.splt
->contents
5554 + abed
->plt
->plt0_got2_offset
);
5556 if (abed
->is_vxworks
)
5558 Elf_Internal_Rela rel
;
5560 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5561 On IA32 we use REL relocations so the addend goes in
5562 the PLT directly. */
5563 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5564 + htab
->elf
.splt
->output_offset
5565 + abed
->plt
->plt0_got1_offset
);
5566 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5567 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5568 htab
->srelplt2
->contents
);
5569 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5570 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5571 + htab
->elf
.splt
->output_offset
5572 + abed
->plt
->plt0_got2_offset
);
5573 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5574 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5575 htab
->srelplt2
->contents
+
5576 sizeof (Elf32_External_Rel
));
5580 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5581 really seem like the right value. */
5582 elf_section_data (htab
->elf
.splt
->output_section
)
5583 ->this_hdr
.sh_entsize
= 4;
5585 /* Correct the .rel.plt.unloaded relocations. */
5586 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5588 int num_plts
= (htab
->elf
.splt
->size
5589 / abed
->plt
->plt_entry_size
) - 1;
5592 p
= htab
->srelplt2
->contents
;
5593 if (bfd_link_pic (info
))
5594 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5596 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5598 for (; num_plts
; num_plts
--)
5600 Elf_Internal_Rela rel
;
5601 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5602 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5603 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5604 p
+= sizeof (Elf32_External_Rel
);
5606 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5607 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5608 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5609 p
+= sizeof (Elf32_External_Rel
);
5615 if (htab
->elf
.sgotplt
)
5617 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5619 (*_bfd_error_handler
)
5620 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5624 /* Fill in the first three entries in the global offset table. */
5625 if (htab
->elf
.sgotplt
->size
> 0)
5627 bfd_put_32 (output_bfd
,
5629 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5630 htab
->elf
.sgotplt
->contents
);
5631 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5632 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5635 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5638 /* Adjust .eh_frame for .plt section. */
5639 if (htab
->plt_eh_frame
!= NULL
5640 && htab
->plt_eh_frame
->contents
!= NULL
)
5642 if (htab
->elf
.splt
!= NULL
5643 && htab
->elf
.splt
->size
!= 0
5644 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5645 && htab
->elf
.splt
->output_section
!= NULL
5646 && htab
->plt_eh_frame
->output_section
!= NULL
)
5648 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5649 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5650 + htab
->plt_eh_frame
->output_offset
5651 + PLT_FDE_START_OFFSET
;
5652 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5653 htab
->plt_eh_frame
->contents
5654 + PLT_FDE_START_OFFSET
);
5656 if (htab
->plt_eh_frame
->sec_info_type
5657 == SEC_INFO_TYPE_EH_FRAME
)
5659 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5661 htab
->plt_eh_frame
->contents
))
5666 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5667 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5669 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5670 htab_traverse (htab
->loc_hash_table
,
5671 elf_i386_finish_local_dynamic_symbol
,
5674 /* Fill PLT entries for undefined weak symbols in PIE. */
5675 if (bfd_link_pie (info
))
5676 bfd_hash_traverse (&info
->hash
->table
,
5677 elf_i386_pie_finish_undefweak_symbol
,
5683 /* Return an array of PLT entry symbol values. */
5686 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5689 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5692 bfd_vma
*plt_sym_val
;
5694 bfd_byte
*plt_contents
;
5695 const struct elf_i386_backend_data
*bed
5696 = get_elf_i386_backend_data (abfd
);
5697 Elf_Internal_Shdr
*hdr
;
5699 /* Get the .plt section contents. */
5700 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5701 if (plt_contents
== NULL
)
5703 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5704 plt_contents
, 0, plt
->size
))
5707 free (plt_contents
);
5711 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5712 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5715 hdr
= &elf_section_data (relplt
)->this_hdr
;
5716 count
= relplt
->size
/ hdr
->sh_entsize
;
5718 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5719 if (plt_sym_val
== NULL
)
5722 for (i
= 0; i
< count
; i
++)
5723 plt_sym_val
[i
] = -1;
5725 plt_offset
= bed
->plt
->plt_entry_size
;
5726 p
= relplt
->relocation
;
5727 for (i
= 0; i
< count
; i
++, p
++)
5731 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5732 if (p
->howto
== NULL
)
5735 if (p
->howto
->type
!= R_386_JUMP_SLOT
5736 && p
->howto
->type
!= R_386_IRELATIVE
)
5739 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5740 + bed
->plt
->plt_reloc_offset
));
5741 reloc_index
/= sizeof (Elf32_External_Rel
);
5742 if (reloc_index
< count
)
5743 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5745 plt_offset
+= bed
->plt
->plt_entry_size
;
5747 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5749 if (plt_offset
>= plt
->size
)
5753 free (plt_contents
);
5758 /* Similar to _bfd_elf_get_synthetic_symtab. */
5761 elf_i386_get_synthetic_symtab (bfd
*abfd
,
5768 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
5769 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5770 dynsymcount
, dynsyms
, ret
,
5772 elf_i386_get_plt_sym_val
);
5775 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5778 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
5780 if (h
->plt
.offset
!= (bfd_vma
) -1
5782 && !h
->pointer_equality_needed
)
5785 return _bfd_elf_hash_symbol (h
);
5788 /* Hook called by the linker routine which adds symbols from an object
5792 elf_i386_add_symbol_hook (bfd
* abfd
,
5793 struct bfd_link_info
* info
,
5794 Elf_Internal_Sym
* sym
,
5795 const char ** namep ATTRIBUTE_UNUSED
,
5796 flagword
* flagsp ATTRIBUTE_UNUSED
,
5797 asection
** secp ATTRIBUTE_UNUSED
,
5798 bfd_vma
* valp ATTRIBUTE_UNUSED
)
5800 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
5801 && (abfd
->flags
& DYNAMIC
) == 0
5802 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5803 elf_tdata (info
->output_bfd
)->has_gnu_symbols
5804 |= elf_gnu_symbol_unique
;
5809 #define TARGET_LITTLE_SYM i386_elf32_vec
5810 #define TARGET_LITTLE_NAME "elf32-i386"
5811 #define ELF_ARCH bfd_arch_i386
5812 #define ELF_TARGET_ID I386_ELF_DATA
5813 #define ELF_MACHINE_CODE EM_386
5814 #define ELF_MAXPAGESIZE 0x1000
5816 #define elf_backend_can_gc_sections 1
5817 #define elf_backend_can_refcount 1
5818 #define elf_backend_want_got_plt 1
5819 #define elf_backend_plt_readonly 1
5820 #define elf_backend_want_plt_sym 0
5821 #define elf_backend_got_header_size 12
5822 #define elf_backend_plt_alignment 4
5823 #define elf_backend_extern_protected_data 1
5825 /* Support RELA for objdump of prelink objects. */
5826 #define elf_info_to_howto elf_i386_info_to_howto_rel
5827 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5829 #define bfd_elf32_mkobject elf_i386_mkobject
5831 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5832 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5833 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5834 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5835 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5837 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5838 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5839 #define elf_backend_check_relocs elf_i386_check_relocs
5840 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5841 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5842 #define elf_backend_fake_sections elf_i386_fake_sections
5843 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5844 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5845 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5846 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5847 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5848 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5849 #define elf_backend_relocate_section elf_i386_relocate_section
5850 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5851 #define elf_backend_always_size_sections elf_i386_always_size_sections
5852 #define elf_backend_omit_section_dynsym \
5853 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5854 #define elf_backend_hash_symbol elf_i386_hash_symbol
5855 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5856 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5858 #include "elf32-target.h"
5860 /* FreeBSD support. */
5862 #undef TARGET_LITTLE_SYM
5863 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5864 #undef TARGET_LITTLE_NAME
5865 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5867 #define ELF_OSABI ELFOSABI_FREEBSD
5869 /* The kernel recognizes executables as valid only if they carry a
5870 "FreeBSD" label in the ELF header. So we put this label on all
5871 executables and (for simplicity) also all other object files. */
5874 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
5876 _bfd_elf_post_process_headers (abfd
, info
);
5878 #ifdef OLD_FREEBSD_ABI_LABEL
5880 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5881 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5882 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5887 #undef elf_backend_post_process_headers
5888 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5890 #define elf32_bed elf32_i386_fbsd_bed
5892 #undef elf_backend_add_symbol_hook
5894 #include "elf32-target.h"
5898 #undef TARGET_LITTLE_SYM
5899 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5900 #undef TARGET_LITTLE_NAME
5901 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5903 #undef elf_backend_post_process_headers
5905 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5906 objects won't be recognized. */
5910 #define elf32_bed elf32_i386_sol2_bed
5912 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5914 #undef elf_backend_static_tls_alignment
5915 #define elf_backend_static_tls_alignment 8
5917 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5919 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5921 #undef elf_backend_want_plt_sym
5922 #define elf_backend_want_plt_sym 1
5924 #undef elf_backend_strtab_flags
5925 #define elf_backend_strtab_flags SHF_STRINGS
5927 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5928 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5929 FALSE otherwise. ISECTION is the best guess matching section from the
5930 input bfd IBFD, but it might be NULL. */
5933 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
5934 bfd
*obfd ATTRIBUTE_UNUSED
,
5935 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
5936 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
5938 /* PR 19938: FIXME: Need to add code for setting the sh_info
5939 and sh_link fields of Solaris specific section types. */
5942 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5943 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5945 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5947 The following values should be set:
5950 -----------------------------------------------------------------------------
5951 SHT_SUNW_ancillary The section header index of 0
5952 [0x6fffffee] the associated string table.
5954 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5955 [0x6ffffff0] the associated symbol table. section header index of
5957 SHT_SUNW_capchain table,
5960 SHT_SUNW_symsort The section header index of 0
5961 [0x6ffffff1] the associated symbol table.
5963 SHT_SUNW_tlssort The section header index of 0
5964 [0x6ffffff2] the associated symbol table.
5966 SHT_SUNW_LDYNSYM The section header index of One greater than the
5967 [0x6ffffff3] the associated string table. symbol table index of the
5968 This index is the same string last local symbol,
5969 table used by the SHT_DYNSYM STB_LOCAL. Since
5970 section. SHT_SUNW_LDYNSYM only
5971 contains local symbols,
5972 sh_info is equivalent to
5973 the number of symbols in
5976 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5977 [0x6ffffff5] the section header index of to named strings, the
5978 the associated section header index of
5979 SHT_SUNW_capinfo table, the associated string
5980 otherwise 0. table, otherwise 0.
5982 SHT_SUNW_move The section header index of 0
5983 [0x6ffffffa] the associated symbol table.
5988 SHT_SUNW_syminfo The section header index of The section header index
5989 [0x6ffffffc] the associated symbol table. of the associated
5992 SHT_SUNW_verdef The section header index of The number of version
5993 [0x6ffffffd] the associated string table. definitions within the
5996 SHT_SUNW_verneed The section header index of The number of version
5997 [0x6ffffffe] the associated string table. dependencies within the
6000 SHT_SUNW_versym The section header index of 0
6001 [0x6fffffff] the associated symbol table. */
6004 #undef elf_backend_copy_special_section_fields
6005 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6007 #include "elf32-target.h"
6009 /* Intel MCU support. */
6012 elf32_iamcu_elf_object_p (bfd
*abfd
)
6014 /* Set the right machine number for an IAMCU elf32 file. */
6015 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6019 #undef TARGET_LITTLE_SYM
6020 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6021 #undef TARGET_LITTLE_NAME
6022 #define TARGET_LITTLE_NAME "elf32-iamcu"
6024 #define ELF_ARCH bfd_arch_iamcu
6026 #undef ELF_MACHINE_CODE
6027 #define ELF_MACHINE_CODE EM_IAMCU
6032 #define elf32_bed elf32_iamcu_bed
6034 #undef elf_backend_object_p
6035 #define elf_backend_object_p elf32_iamcu_elf_object_p
6037 #undef elf_backend_static_tls_alignment
6039 #undef elf_backend_want_plt_sym
6040 #define elf_backend_want_plt_sym 0
6042 #undef elf_backend_strtab_flags
6043 #undef elf_backend_copy_special_section_fields
6045 #include "elf32-target.h"
6047 /* Restore defaults. */
6049 #define ELF_ARCH bfd_arch_i386
6050 #undef ELF_MACHINE_CODE
6051 #define ELF_MACHINE_CODE EM_386
6053 /* Native Client support. */
6055 #undef TARGET_LITTLE_SYM
6056 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6057 #undef TARGET_LITTLE_NAME
6058 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6060 #define elf32_bed elf32_i386_nacl_bed
6062 #undef ELF_MAXPAGESIZE
6063 #define ELF_MAXPAGESIZE 0x10000
6065 /* Restore defaults. */
6067 #undef elf_backend_want_plt_sym
6068 #define elf_backend_want_plt_sym 0
6069 #undef elf_backend_post_process_headers
6070 #undef elf_backend_static_tls_alignment
6072 /* NaCl uses substantially different PLT entries for the same effects. */
6074 #undef elf_backend_plt_alignment
6075 #define elf_backend_plt_alignment 5
6076 #define NACL_PLT_ENTRY_SIZE 64
6077 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6079 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6081 0xff, 0x35, /* pushl contents of address */
6082 0, 0, 0, 0, /* replaced with address of .got + 4. */
6083 0x8b, 0x0d, /* movl contents of address, %ecx */
6084 0, 0, 0, 0, /* replaced with address of .got + 8. */
6085 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6086 0xff, 0xe1 /* jmp *%ecx */
6089 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6091 0x8b, 0x0d, /* movl contents of address, %ecx */
6092 0, 0, 0, 0, /* replaced with GOT slot address. */
6093 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6094 0xff, 0xe1, /* jmp *%ecx */
6096 /* Pad to the next 32-byte boundary with nop instructions. */
6098 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6099 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6101 /* Lazy GOT entries point here (32-byte aligned). */
6102 0x68, /* pushl immediate */
6103 0, 0, 0, 0, /* replaced with reloc offset. */
6104 0xe9, /* jmp relative */
6105 0, 0, 0, 0, /* replaced with offset to .plt. */
6107 /* Pad to the next 32-byte boundary with nop instructions. */
6108 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6109 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6113 static const bfd_byte
6114 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6116 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6117 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6118 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6119 0xff, 0xe1, /* jmp *%ecx */
6121 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6122 so pad to that size with nop instructions. */
6123 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6126 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6128 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6129 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6130 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6131 0xff, 0xe1, /* jmp *%ecx */
6133 /* Pad to the next 32-byte boundary with nop instructions. */
6135 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6136 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6138 /* Lazy GOT entries point here (32-byte aligned). */
6139 0x68, /* pushl immediate */
6140 0, 0, 0, 0, /* replaced with offset into relocation table. */
6141 0xe9, /* jmp relative */
6142 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6144 /* Pad to the next 32-byte boundary with nop instructions. */
6145 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6146 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6150 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6152 #if (PLT_CIE_LENGTH != 20 \
6153 || PLT_FDE_LENGTH != 36 \
6154 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6155 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6156 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6158 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6159 0, 0, 0, 0, /* CIE ID */
6160 1, /* CIE version */
6161 'z', 'R', 0, /* Augmentation string */
6162 1, /* Code alignment factor */
6163 0x7c, /* Data alignment factor: -4 */
6164 8, /* Return address column */
6165 1, /* Augmentation size */
6166 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6167 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6168 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6169 DW_CFA_nop
, DW_CFA_nop
,
6171 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6172 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6173 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6174 0, 0, 0, 0, /* .plt size goes here */
6175 0, /* Augmentation size */
6176 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6177 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6178 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6179 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6180 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6181 13, /* Block length */
6182 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6183 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6184 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6185 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6186 DW_CFA_nop
, DW_CFA_nop
6189 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6191 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6192 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6193 2, /* plt0_got1_offset */
6194 8, /* plt0_got2_offset */
6195 elf_i386_nacl_plt_entry
, /* plt_entry */
6196 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6197 2, /* plt_got_offset */
6198 33, /* plt_reloc_offset */
6199 38, /* plt_plt_offset */
6200 32, /* plt_lazy_offset */
6201 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6202 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6203 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6204 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6207 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6209 &elf_i386_nacl_plt
, /* plt */
6210 0x90, /* plt0_pad_byte: nop insn */
6215 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6217 /* Set the right machine number for a NaCl i386 ELF32 file. */
6218 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6222 #undef elf_backend_arch_data
6223 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6225 #undef elf_backend_object_p
6226 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6227 #undef elf_backend_modify_segment_map
6228 #define elf_backend_modify_segment_map nacl_modify_segment_map
6229 #undef elf_backend_modify_program_headers
6230 #define elf_backend_modify_program_headers nacl_modify_program_headers
6231 #undef elf_backend_final_write_processing
6232 #define elf_backend_final_write_processing nacl_final_write_processing
6234 #include "elf32-target.h"
6236 /* Restore defaults. */
6237 #undef elf_backend_object_p
6238 #undef elf_backend_modify_segment_map
6239 #undef elf_backend_modify_program_headers
6240 #undef elf_backend_final_write_processing
6242 /* VxWorks support. */
6244 #undef TARGET_LITTLE_SYM
6245 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6246 #undef TARGET_LITTLE_NAME
6247 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6249 #undef elf_backend_plt_alignment
6250 #define elf_backend_plt_alignment 4
6252 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6254 &elf_i386_plt
, /* plt */
6255 0x90, /* plt0_pad_byte */
6259 #undef elf_backend_arch_data
6260 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6262 #undef elf_backend_relocs_compatible
6263 #undef elf_backend_add_symbol_hook
6264 #define elf_backend_add_symbol_hook \
6265 elf_vxworks_add_symbol_hook
6266 #undef elf_backend_link_output_symbol_hook
6267 #define elf_backend_link_output_symbol_hook \
6268 elf_vxworks_link_output_symbol_hook
6269 #undef elf_backend_emit_relocs
6270 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6271 #undef elf_backend_final_write_processing
6272 #define elf_backend_final_write_processing \
6273 elf_vxworks_final_write_processing
6274 #undef elf_backend_static_tls_alignment
6276 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6278 #undef elf_backend_want_plt_sym
6279 #define elf_backend_want_plt_sym 1
6282 #define elf32_bed elf32_i386_vxworks_bed
6284 #include "elf32-target.h"