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 /* 0: symbol isn't ___tls_get_addr.
791 1: symbol is ___tls_get_addr.
792 2: symbol is unknown. */
793 unsigned int tls_get_addr
: 2;
795 /* Reference count of C/C++ function pointer relocations in read-write
796 section which can be resolved at run-time. */
797 bfd_signed_vma func_pointer_refcount
;
799 /* Information about the GOT PLT entry. Filled when there are both
800 GOT and PLT relocations against the same function. */
801 union gotplt_union plt_got
;
803 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
804 starting at the end of the jump table. */
808 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
810 struct elf_i386_obj_tdata
812 struct elf_obj_tdata root
;
814 /* tls_type for each local got entry. */
815 char *local_got_tls_type
;
817 /* GOTPLT entries for TLS descriptors. */
818 bfd_vma
*local_tlsdesc_gotent
;
821 #define elf_i386_tdata(abfd) \
822 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
824 #define elf_i386_local_got_tls_type(abfd) \
825 (elf_i386_tdata (abfd)->local_got_tls_type)
827 #define elf_i386_local_tlsdesc_gotent(abfd) \
828 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
830 #define is_i386_elf(bfd) \
831 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
832 && elf_tdata (bfd) != NULL \
833 && elf_object_id (bfd) == I386_ELF_DATA)
836 elf_i386_mkobject (bfd
*abfd
)
838 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
842 /* i386 ELF linker hash table. */
844 struct elf_i386_link_hash_table
846 struct elf_link_hash_table elf
;
848 /* Short-cuts to get to dynamic linker sections. */
852 asection
*plt_eh_frame
;
857 bfd_signed_vma refcount
;
861 /* The amount of space used by the reserved portion of the sgotplt
862 section, plus whatever space is used by the jump slots. */
863 bfd_vma sgotplt_jump_table_size
;
865 /* Small local sym cache. */
866 struct sym_cache sym_cache
;
868 /* _TLS_MODULE_BASE_ symbol. */
869 struct bfd_link_hash_entry
*tls_module_base
;
871 /* Used by local STT_GNU_IFUNC symbols. */
872 htab_t loc_hash_table
;
873 void * loc_hash_memory
;
875 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
878 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
879 bfd_vma next_tls_desc_index
;
881 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
882 bfd_vma next_jump_slot_index
;
884 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
885 bfd_vma next_irelative_index
;
887 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
888 to read-only sections. */
889 bfd_boolean readonly_dynrelocs_against_ifunc
;
892 /* Get the i386 ELF linker hash table from a link_info structure. */
894 #define elf_i386_hash_table(p) \
895 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
896 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
898 #define elf_i386_compute_jump_table_size(htab) \
899 ((htab)->elf.srelplt->reloc_count * 4)
901 /* Create an entry in an i386 ELF linker hash table. */
903 static struct bfd_hash_entry
*
904 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
905 struct bfd_hash_table
*table
,
908 /* Allocate the structure if it has not already been allocated by a
912 entry
= (struct bfd_hash_entry
*)
913 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
918 /* Call the allocation method of the superclass. */
919 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
922 struct elf_i386_link_hash_entry
*eh
;
924 eh
= (struct elf_i386_link_hash_entry
*) entry
;
925 eh
->dyn_relocs
= NULL
;
926 eh
->tls_type
= GOT_UNKNOWN
;
928 eh
->has_got_reloc
= 0;
929 eh
->has_non_got_reloc
= 0;
930 eh
->tls_get_addr
= 2;
931 eh
->func_pointer_refcount
= 0;
932 eh
->plt_got
.offset
= (bfd_vma
) -1;
933 eh
->tlsdesc_got
= (bfd_vma
) -1;
939 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
940 for local symbol so that we can handle local STT_GNU_IFUNC symbols
941 as global symbol. We reuse indx and dynstr_index for local symbol
942 hash since they aren't used by global symbols in this backend. */
945 elf_i386_local_htab_hash (const void *ptr
)
947 struct elf_link_hash_entry
*h
948 = (struct elf_link_hash_entry
*) ptr
;
949 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
952 /* Compare local hash entries. */
955 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
957 struct elf_link_hash_entry
*h1
958 = (struct elf_link_hash_entry
*) ptr1
;
959 struct elf_link_hash_entry
*h2
960 = (struct elf_link_hash_entry
*) ptr2
;
962 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
965 /* Find and/or create a hash entry for local symbol. */
967 static struct elf_link_hash_entry
*
968 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
969 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
972 struct elf_i386_link_hash_entry e
, *ret
;
973 asection
*sec
= abfd
->sections
;
974 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
975 ELF32_R_SYM (rel
->r_info
));
978 e
.elf
.indx
= sec
->id
;
979 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
980 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
981 create
? INSERT
: NO_INSERT
);
988 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
992 ret
= (struct elf_i386_link_hash_entry
*)
993 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
994 sizeof (struct elf_i386_link_hash_entry
));
997 memset (ret
, 0, sizeof (*ret
));
998 ret
->elf
.indx
= sec
->id
;
999 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
1000 ret
->elf
.dynindx
= -1;
1001 ret
->func_pointer_refcount
= 0;
1002 ret
->plt_got
.offset
= (bfd_vma
) -1;
1008 /* Destroy an i386 ELF linker hash table. */
1011 elf_i386_link_hash_table_free (bfd
*obfd
)
1013 struct elf_i386_link_hash_table
*htab
1014 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1016 if (htab
->loc_hash_table
)
1017 htab_delete (htab
->loc_hash_table
);
1018 if (htab
->loc_hash_memory
)
1019 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1020 _bfd_elf_link_hash_table_free (obfd
);
1023 /* Create an i386 ELF linker hash table. */
1025 static struct bfd_link_hash_table
*
1026 elf_i386_link_hash_table_create (bfd
*abfd
)
1028 struct elf_i386_link_hash_table
*ret
;
1029 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1031 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1035 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1036 elf_i386_link_hash_newfunc
,
1037 sizeof (struct elf_i386_link_hash_entry
),
1044 ret
->loc_hash_table
= htab_try_create (1024,
1045 elf_i386_local_htab_hash
,
1046 elf_i386_local_htab_eq
,
1048 ret
->loc_hash_memory
= objalloc_create ();
1049 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1051 elf_i386_link_hash_table_free (abfd
);
1054 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1056 return &ret
->elf
.root
;
1059 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1060 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1064 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1066 struct elf_i386_link_hash_table
*htab
;
1068 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1071 htab
= elf_i386_hash_table (info
);
1075 /* Set the contents of the .interp section to the interpreter. */
1076 if (bfd_link_executable (info
) && !info
->nointerp
)
1078 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1081 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1082 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1086 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1090 if (bfd_link_executable (info
))
1092 /* Always allow copy relocs for building executables. */
1093 asection
*s
= bfd_get_linker_section (dynobj
, ".rel.bss");
1096 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1097 s
= bfd_make_section_anyway_with_flags (dynobj
,
1099 (bed
->dynamic_sec_flags
1102 || ! bfd_set_section_alignment (dynobj
, s
,
1103 bed
->s
->log_file_align
))
1109 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1110 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1114 if (!info
->no_ld_generated_unwind_info
1115 && htab
->plt_eh_frame
== NULL
1116 && htab
->elf
.splt
!= NULL
)
1118 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1119 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1120 | SEC_LINKER_CREATED
);
1122 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1123 if (htab
->plt_eh_frame
== NULL
1124 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1131 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1134 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1135 struct elf_link_hash_entry
*dir
,
1136 struct elf_link_hash_entry
*ind
)
1138 struct elf_i386_link_hash_entry
*edir
, *eind
;
1140 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1141 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1143 if (eind
->dyn_relocs
!= NULL
)
1145 if (edir
->dyn_relocs
!= NULL
)
1147 struct elf_dyn_relocs
**pp
;
1148 struct elf_dyn_relocs
*p
;
1150 /* Add reloc counts against the indirect sym to the direct sym
1151 list. Merge any entries against the same section. */
1152 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1154 struct elf_dyn_relocs
*q
;
1156 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1157 if (q
->sec
== p
->sec
)
1159 q
->pc_count
+= p
->pc_count
;
1160 q
->count
+= p
->count
;
1167 *pp
= edir
->dyn_relocs
;
1170 edir
->dyn_relocs
= eind
->dyn_relocs
;
1171 eind
->dyn_relocs
= NULL
;
1174 if (ind
->root
.type
== bfd_link_hash_indirect
1175 && dir
->got
.refcount
<= 0)
1177 edir
->tls_type
= eind
->tls_type
;
1178 eind
->tls_type
= GOT_UNKNOWN
;
1181 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1182 generate a R_386_COPY reloc. */
1183 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1185 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1186 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1188 if (ELIMINATE_COPY_RELOCS
1189 && ind
->root
.type
!= bfd_link_hash_indirect
1190 && dir
->dynamic_adjusted
)
1192 /* If called to transfer flags for a weakdef during processing
1193 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1194 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1195 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1196 dir
->ref_regular
|= ind
->ref_regular
;
1197 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1198 dir
->needs_plt
|= ind
->needs_plt
;
1199 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1203 if (eind
->func_pointer_refcount
> 0)
1205 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1206 eind
->func_pointer_refcount
= 0;
1209 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1213 /* Return TRUE if the TLS access code sequence support transition
1217 elf_i386_check_tls_transition (asection
*sec
,
1219 Elf_Internal_Shdr
*symtab_hdr
,
1220 struct elf_link_hash_entry
**sym_hashes
,
1221 unsigned int r_type
,
1222 const Elf_Internal_Rela
*rel
,
1223 const Elf_Internal_Rela
*relend
)
1225 unsigned int val
, type
, reg
;
1226 unsigned long r_symndx
;
1227 struct elf_link_hash_entry
*h
;
1230 bfd_boolean indirect_call
, tls_get_addr
;
1232 offset
= rel
->r_offset
;
1237 if (offset
< 2 || (rel
+ 1) >= relend
)
1240 indirect_call
= FALSE
;
1241 call
= contents
+ offset
+ 4;
1244 if (r_type
== R_386_TLS_GD
)
1246 /* Check transition from GD access model. Only
1247 leal foo@tlsgd(,%ebx,1), %eax
1248 call ___tls_get_addr@PLT
1250 leal foo@tlsgd(%ebx) %eax
1251 call ___tls_get_addr@PLT
1254 leal foo@tlsgd(%reg), %eax
1255 call *___tls_get_addr@GOT(%reg)
1256 which may be converted to
1257 addr32 call ___tls_get_addr
1258 can transit to different access model. */
1259 if ((offset
+ 10) > sec
->size
1260 || (type
!= 0x8d && type
!= 0x04))
1265 /* leal foo@tlsgd(,%ebx,1), %eax
1266 call ___tls_get_addr@PLT */
1270 if (*(call
- 7) != 0x8d
1278 leal foo@tlsgd(%ebx), %eax
1279 call ___tls_get_addr@PLT
1282 leal foo@tlsgd(%reg), %eax
1283 call *___tls_get_addr@GOT(%reg)
1284 which may be converted to
1285 addr32 call ___tls_get_addr
1287 %eax can't be used as the GOT base register since it
1288 is used to pass parameter to ___tls_get_addr. */
1290 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1293 indirect_call
= call
[0] == 0xff;
1294 if (!(reg
== 3 && call
[0] == 0xe8 && call
[5] == 0x90)
1295 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1297 && (call
[1] & 0xf8) == 0x90
1298 && (call
[1] & 0x7) == reg
))
1304 /* Check transition from LD access model. Only
1305 leal foo@tlsldm(%ebx), %eax
1306 call ___tls_get_addr@PLT
1308 leal foo@tlsldm(%reg), %eax
1309 call *___tls_get_addr@GOT(%reg)
1310 which may be converted to
1311 addr32 call ___tls_get_addr
1312 can transit to different access model. */
1313 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1316 /* %eax can't be used as the GOT base register since it is
1317 used to pass parameter to ___tls_get_addr. */
1319 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1322 indirect_call
= call
[0] == 0xff;
1323 if (!(reg
== 3 && call
[0] == 0xe8)
1324 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1326 && (call
[1] & 0xf8) == 0x90
1327 && (call
[1] & 0x7) == reg
))
1331 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1332 if (r_symndx
< symtab_hdr
->sh_info
)
1335 tls_get_addr
= FALSE
;
1336 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1337 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1339 struct elf_i386_link_hash_entry
*eh
1340 = (struct elf_i386_link_hash_entry
*) h
;
1341 tls_get_addr
= eh
->tls_get_addr
== 1;
1342 if (eh
->tls_get_addr
> 1)
1344 /* Use strncmp to check ___tls_get_addr since
1345 ___tls_get_addr may be versioned. */
1346 if (strncmp (h
->root
.root
.string
, "___tls_get_addr", 15)
1349 eh
->tls_get_addr
= 1;
1350 tls_get_addr
= TRUE
;
1353 eh
->tls_get_addr
= 0;
1359 else if (indirect_call
)
1360 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_GOT32X
);
1362 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1363 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
1366 /* Check transition from IE access model:
1367 movl foo@indntpoff(%rip), %eax
1368 movl foo@indntpoff(%rip), %reg
1369 addl foo@indntpoff(%rip), %reg
1372 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1375 /* Check "movl foo@tpoff(%rip), %eax" first. */
1376 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1383 /* Check movl|addl foo@tpoff(%rip), %reg. */
1384 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1385 return ((type
== 0x8b || type
== 0x03)
1386 && (val
& 0xc7) == 0x05);
1388 case R_386_TLS_GOTIE
:
1389 case R_386_TLS_IE_32
:
1390 /* Check transition from {IE_32,GOTIE} access model:
1391 subl foo@{tpoff,gontoff}(%reg1), %reg2
1392 movl foo@{tpoff,gontoff}(%reg1), %reg2
1393 addl foo@{tpoff,gontoff}(%reg1), %reg2
1396 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1399 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1400 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1403 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1404 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1406 case R_386_TLS_GOTDESC
:
1407 /* Check transition from GDesc access model:
1408 leal x@tlsdesc(%ebx), %eax
1410 Make sure it's a leal adding ebx to a 32-bit offset
1411 into any register, although it's probably almost always
1414 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1417 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1420 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1421 return (val
& 0xc7) == 0x83;
1423 case R_386_TLS_DESC_CALL
:
1424 /* Check transition from GDesc access model:
1425 call *x@tlsdesc(%eax)
1427 if (offset
+ 2 <= sec
->size
)
1429 /* Make sure that it's a call *x@tlsdesc(%eax). */
1430 call
= contents
+ offset
;
1431 return call
[0] == 0xff && call
[1] == 0x10;
1441 /* Return TRUE if the TLS access transition is OK or no transition
1442 will be performed. Update R_TYPE if there is a transition. */
1445 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1446 asection
*sec
, bfd_byte
*contents
,
1447 Elf_Internal_Shdr
*symtab_hdr
,
1448 struct elf_link_hash_entry
**sym_hashes
,
1449 unsigned int *r_type
, int tls_type
,
1450 const Elf_Internal_Rela
*rel
,
1451 const Elf_Internal_Rela
*relend
,
1452 struct elf_link_hash_entry
*h
,
1453 unsigned long r_symndx
,
1454 bfd_boolean from_relocate_section
)
1456 unsigned int from_type
= *r_type
;
1457 unsigned int to_type
= from_type
;
1458 bfd_boolean check
= TRUE
;
1460 /* Skip TLS transition for functions. */
1462 && (h
->type
== STT_FUNC
1463 || h
->type
== STT_GNU_IFUNC
))
1469 case R_386_TLS_GOTDESC
:
1470 case R_386_TLS_DESC_CALL
:
1471 case R_386_TLS_IE_32
:
1473 case R_386_TLS_GOTIE
:
1474 if (bfd_link_executable (info
))
1477 to_type
= R_386_TLS_LE_32
;
1478 else if (from_type
!= R_386_TLS_IE
1479 && from_type
!= R_386_TLS_GOTIE
)
1480 to_type
= R_386_TLS_IE_32
;
1483 /* When we are called from elf_i386_relocate_section, there may
1484 be additional transitions based on TLS_TYPE. */
1485 if (from_relocate_section
)
1487 unsigned int new_to_type
= to_type
;
1489 if (bfd_link_executable (info
)
1492 && (tls_type
& GOT_TLS_IE
))
1493 new_to_type
= R_386_TLS_LE_32
;
1495 if (to_type
== R_386_TLS_GD
1496 || to_type
== R_386_TLS_GOTDESC
1497 || to_type
== R_386_TLS_DESC_CALL
)
1499 if (tls_type
== GOT_TLS_IE_POS
)
1500 new_to_type
= R_386_TLS_GOTIE
;
1501 else if (tls_type
& GOT_TLS_IE
)
1502 new_to_type
= R_386_TLS_IE_32
;
1505 /* We checked the transition before when we were called from
1506 elf_i386_check_relocs. We only want to check the new
1507 transition which hasn't been checked before. */
1508 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1509 to_type
= new_to_type
;
1515 if (bfd_link_executable (info
))
1516 to_type
= R_386_TLS_LE_32
;
1523 /* Return TRUE if there is no transition. */
1524 if (from_type
== to_type
)
1527 /* Check if the transition can be performed. */
1529 && ! elf_i386_check_tls_transition (sec
, contents
,
1530 symtab_hdr
, sym_hashes
,
1531 from_type
, rel
, relend
))
1533 reloc_howto_type
*from
, *to
;
1536 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1537 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1540 name
= h
->root
.root
.string
;
1543 struct elf_i386_link_hash_table
*htab
;
1545 htab
= elf_i386_hash_table (info
);
1550 Elf_Internal_Sym
*isym
;
1552 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1554 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1559 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1560 "in section `%A' failed"),
1561 abfd
, sec
, from
->name
, to
->name
, name
,
1562 (unsigned long) rel
->r_offset
);
1563 bfd_set_error (bfd_error_bad_value
);
1571 /* With the local symbol, foo, we convert
1572 mov foo@GOT[(%reg1)], %reg2
1574 lea foo[@GOTOFF(%reg1)], %reg2
1576 call/jmp *foo@GOT[(%reg)]
1578 nop call foo/jmp foo nop
1579 When PIC is false, convert
1580 test %reg1, foo@GOT[(%reg2)]
1584 binop foo@GOT[(%reg1)], %reg2
1587 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1592 elf_i386_convert_load_reloc (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
1594 Elf_Internal_Rela
*irel
,
1595 struct elf_link_hash_entry
*h
,
1596 bfd_boolean
*converted
,
1597 struct bfd_link_info
*link_info
)
1599 struct elf_i386_link_hash_table
*htab
;
1600 unsigned int opcode
;
1602 bfd_boolean baseless
;
1603 Elf_Internal_Sym
*isym
;
1604 unsigned int addend
;
1608 bfd_boolean to_reloc_32
;
1609 unsigned int r_type
;
1610 unsigned int r_symndx
;
1611 bfd_vma roff
= irel
->r_offset
;
1616 /* Addend for R_386_GOT32X relocations must be 0. */
1617 addend
= bfd_get_32 (abfd
, contents
+ roff
);
1621 htab
= elf_i386_hash_table (link_info
);
1622 is_pic
= bfd_link_pic (link_info
);
1624 r_type
= ELF32_R_TYPE (irel
->r_info
);
1625 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1627 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1628 baseless
= (modrm
& 0xc7) == 0x5;
1630 if (baseless
&& is_pic
)
1632 /* For PIC, disallow R_386_GOT32X without a base register
1633 since we don't know what the GOT base is. */
1638 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
1640 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1643 name
= h
->root
.root
.string
;
1646 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1651 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1653 /* Convert to R_386_32 if PIC is false or there is no base
1655 to_reloc_32
= !is_pic
|| baseless
;
1657 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1661 if (opcode
== 0x0ff)
1662 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1663 goto convert_branch
;
1665 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1666 "test %reg1, foo@GOT(%reg2)" and
1667 "binop foo@GOT[(%reg1)], %reg2". */
1671 /* Undefined weak symbol is only bound locally in executable
1672 and its reference is resolved as 0. */
1673 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
1674 elf_i386_hash_entry (h
)))
1678 /* No direct branch to 0 for PIC. */
1682 goto convert_branch
;
1686 /* We can convert load of address 0 to R_386_32. */
1694 /* We have "call/jmp *foo@GOT[(%reg)]". */
1695 if ((h
->root
.type
== bfd_link_hash_defined
1696 || h
->root
.type
== bfd_link_hash_defweak
)
1697 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1699 /* The function is locally defined. */
1701 /* Convert R_386_GOT32X to R_386_PC32. */
1702 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
1704 struct elf_i386_link_hash_entry
*eh
1705 = (struct elf_i386_link_hash_entry
*) h
;
1707 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1710 /* To support TLS optimization, always use addr32 prefix
1711 for "call *___tls_get_addr@GOT(%reg)". */
1712 if (eh
&& eh
->tls_get_addr
== 1)
1715 nop_offset
= irel
->r_offset
- 2;
1719 nop
= link_info
->call_nop_byte
;
1720 if (link_info
->call_nop_as_suffix
)
1722 nop_offset
= roff
+ 3;
1723 irel
->r_offset
-= 1;
1726 nop_offset
= roff
- 2;
1731 /* Convert to "jmp foo nop". */
1734 nop_offset
= roff
+ 3;
1735 irel
->r_offset
-= 1;
1738 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1739 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1740 /* When converting to PC-relative relocation, we
1741 need to adjust addend by -4. */
1742 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
1743 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
1750 /* We have "mov foo@GOT[(%re1g)], %reg2",
1751 "test %reg1, foo@GOT(%reg2)" and
1752 "binop foo@GOT[(%reg1)], %reg2".
1754 Avoid optimizing _DYNAMIC since ld.so may use its
1755 link-time address. */
1756 if (h
== htab
->elf
.hdynamic
)
1759 /* def_regular is set by an assignment in a linker script in
1760 bfd_elf_record_link_assignment. */
1762 || h
->root
.type
== bfd_link_hash_defined
1763 || h
->root
.type
== bfd_link_hash_defweak
)
1764 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1771 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1772 "mov $foo, %reg2" with R_386_32. */
1774 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1775 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1780 /* Convert "mov foo@GOT(%reg1), %reg2" to
1781 "lea foo@GOTOFF(%reg1), %reg2". */
1782 r_type
= R_386_GOTOFF
;
1788 /* Only R_386_32 is supported. */
1794 /* Convert "test %reg1, foo@GOT(%reg2)" to
1795 "test $foo, %reg1". */
1796 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1801 /* Convert "binop foo@GOT(%reg1), %reg2" to
1802 "binop $foo, %reg2". */
1804 | (modrm
& 0x38) >> 3
1808 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1812 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1813 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1822 /* Rename some of the generic section flags to better document how they
1824 #define need_convert_load sec_flg0
1825 #define check_relocs_failed sec_flg1
1827 /* Look through the relocs for a section during the first phase, and
1828 calculate needed space in the global offset table, procedure linkage
1829 table, and dynamic reloc sections. */
1832 elf_i386_check_relocs (bfd
*abfd
,
1833 struct bfd_link_info
*info
,
1835 const Elf_Internal_Rela
*relocs
)
1837 struct elf_i386_link_hash_table
*htab
;
1838 Elf_Internal_Shdr
*symtab_hdr
;
1839 struct elf_link_hash_entry
**sym_hashes
;
1840 const Elf_Internal_Rela
*rel
;
1841 const Elf_Internal_Rela
*rel_end
;
1844 bfd_boolean use_plt_got
;
1846 if (bfd_link_relocatable (info
))
1849 /* Don't do anything special with non-loaded, non-alloced sections.
1850 In particular, any relocs in such sections should not affect GOT
1851 and PLT reference counting (ie. we don't allow them to create GOT
1852 or PLT entries), there's no possibility or desire to optimize TLS
1853 relocs, and there's not much point in propagating relocs to shared
1854 libs that the dynamic linker won't relocate. */
1855 if ((sec
->flags
& SEC_ALLOC
) == 0)
1858 BFD_ASSERT (is_i386_elf (abfd
));
1860 htab
= elf_i386_hash_table (info
);
1863 sec
->check_relocs_failed
= 1;
1867 /* Get the section contents. */
1868 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1869 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1870 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1872 sec
->check_relocs_failed
= 1;
1876 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1877 && (get_elf_i386_backend_data (abfd
)
1878 == &elf_i386_arch_bed
));
1880 symtab_hdr
= &elf_symtab_hdr (abfd
);
1881 sym_hashes
= elf_sym_hashes (abfd
);
1885 rel_end
= relocs
+ sec
->reloc_count
;
1886 for (rel
= relocs
; rel
< rel_end
; rel
++)
1888 unsigned int r_type
;
1889 unsigned long r_symndx
;
1890 struct elf_link_hash_entry
*h
;
1891 struct elf_i386_link_hash_entry
*eh
;
1892 Elf_Internal_Sym
*isym
;
1894 bfd_boolean size_reloc
;
1896 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1897 r_type
= ELF32_R_TYPE (rel
->r_info
);
1899 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1901 _bfd_error_handler (_("%B: bad symbol index: %d"),
1906 if (r_symndx
< symtab_hdr
->sh_info
)
1908 /* A local symbol. */
1909 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1914 /* Check relocation against local STT_GNU_IFUNC symbol. */
1915 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1917 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1921 /* Fake a STT_GNU_IFUNC symbol. */
1922 h
->type
= STT_GNU_IFUNC
;
1925 h
->forced_local
= 1;
1926 h
->root
.type
= bfd_link_hash_defined
;
1934 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1935 while (h
->root
.type
== bfd_link_hash_indirect
1936 || h
->root
.type
== bfd_link_hash_warning
)
1937 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1940 eh
= (struct elf_i386_link_hash_entry
*) h
;
1955 if (htab
->elf
.dynobj
== NULL
)
1956 htab
->elf
.dynobj
= abfd
;
1957 /* Create the ifunc sections for static executables. */
1958 if (h
->type
== STT_GNU_IFUNC
1959 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1965 /* It is referenced by a non-shared object. */
1967 h
->root
.non_ir_ref
= 1;
1969 if (h
->type
== STT_GNU_IFUNC
)
1970 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1971 |= elf_gnu_symbol_ifunc
;
1974 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1975 symtab_hdr
, sym_hashes
,
1976 &r_type
, GOT_UNKNOWN
,
1977 rel
, rel_end
, h
, r_symndx
, FALSE
))
1983 htab
->tls_ldm_got
.refcount
+= 1;
1987 /* This symbol requires a procedure linkage table entry. We
1988 actually build the entry in adjust_dynamic_symbol,
1989 because this might be a case of linking PIC code which is
1990 never referenced by a dynamic object, in which case we
1991 don't need to generate a procedure linkage table entry
1994 /* If this is a local symbol, we resolve it directly without
1995 creating a procedure linkage table entry. */
1999 eh
->has_got_reloc
= 1;
2001 h
->plt
.refcount
+= 1;
2008 case R_386_TLS_IE_32
:
2010 case R_386_TLS_GOTIE
:
2011 if (!bfd_link_executable (info
))
2012 info
->flags
|= DF_STATIC_TLS
;
2018 case R_386_TLS_GOTDESC
:
2019 case R_386_TLS_DESC_CALL
:
2020 /* This symbol requires a global offset table entry. */
2022 int tls_type
, old_tls_type
;
2029 tls_type
= GOT_NORMAL
;
2031 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
2032 case R_386_TLS_GOTDESC
:
2033 case R_386_TLS_DESC_CALL
:
2034 tls_type
= GOT_TLS_GDESC
; break;
2035 case R_386_TLS_IE_32
:
2036 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
2037 tls_type
= GOT_TLS_IE_NEG
;
2039 /* If this is a GD->IE transition, we may use either of
2040 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2041 tls_type
= GOT_TLS_IE
;
2044 case R_386_TLS_GOTIE
:
2045 tls_type
= GOT_TLS_IE_POS
; break;
2050 h
->got
.refcount
+= 1;
2051 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2055 bfd_signed_vma
*local_got_refcounts
;
2057 /* This is a global offset table entry for a local symbol. */
2058 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2059 if (local_got_refcounts
== NULL
)
2063 size
= symtab_hdr
->sh_info
;
2064 size
*= (sizeof (bfd_signed_vma
)
2065 + sizeof (bfd_vma
) + sizeof(char));
2066 local_got_refcounts
= (bfd_signed_vma
*)
2067 bfd_zalloc (abfd
, size
);
2068 if (local_got_refcounts
== NULL
)
2070 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2071 elf_i386_local_tlsdesc_gotent (abfd
)
2072 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2073 elf_i386_local_got_tls_type (abfd
)
2074 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2076 local_got_refcounts
[r_symndx
] += 1;
2077 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
2080 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
2081 tls_type
|= old_tls_type
;
2082 /* If a TLS symbol is accessed using IE at least once,
2083 there is no point to use dynamic model for it. */
2084 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2085 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2086 || (tls_type
& GOT_TLS_IE
) == 0))
2088 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
2089 tls_type
= old_tls_type
;
2090 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2091 && GOT_TLS_GD_ANY_P (tls_type
))
2092 tls_type
|= old_tls_type
;
2096 name
= h
->root
.root
.string
;
2098 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2101 (_("%B: `%s' accessed both as normal and "
2102 "thread local symbol"),
2104 bfd_set_error (bfd_error_bad_value
);
2109 if (old_tls_type
!= tls_type
)
2112 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2114 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2122 if (htab
->elf
.sgot
== NULL
)
2124 if (htab
->elf
.dynobj
== NULL
)
2125 htab
->elf
.dynobj
= abfd
;
2126 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
2129 if (r_type
!= R_386_TLS_IE
)
2132 eh
->has_got_reloc
= 1;
2137 case R_386_TLS_LE_32
:
2140 eh
->has_got_reloc
= 1;
2141 if (bfd_link_executable (info
))
2143 info
->flags
|= DF_STATIC_TLS
;
2148 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2149 eh
->has_non_got_reloc
= 1;
2151 /* We are called after all symbols have been resolved. Only
2152 relocation against STT_GNU_IFUNC symbol must go through
2155 && (bfd_link_executable (info
)
2156 || h
->type
== STT_GNU_IFUNC
))
2158 /* If this reloc is in a read-only section, we might
2159 need a copy reloc. We can't check reliably at this
2160 stage whether the section is read-only, as input
2161 sections have not yet been mapped to output sections.
2162 Tentatively set the flag for now, and correct in
2163 adjust_dynamic_symbol. */
2166 /* We may need a .plt entry if the symbol is a function
2167 defined in a shared lib or is a STT_GNU_IFUNC function
2168 referenced from the code or read-only section. */
2170 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2171 h
->plt
.refcount
+= 1;
2173 if (r_type
== R_386_PC32
)
2175 /* Since something like ".long foo - ." may be used
2176 as pointer, make sure that PLT is used if foo is
2177 a function defined in a shared library. */
2178 if ((sec
->flags
& SEC_CODE
) == 0)
2179 h
->pointer_equality_needed
= 1;
2180 else if (h
->type
== STT_GNU_IFUNC
2181 && bfd_link_pic (info
))
2184 name
= h
->root
.root
.string
;
2186 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2189 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2191 bfd_set_error (bfd_error_bad_value
);
2197 h
->pointer_equality_needed
= 1;
2198 /* R_386_32 can be resolved at run-time. */
2199 if (r_type
== R_386_32
2200 && (sec
->flags
& SEC_READONLY
) == 0)
2201 eh
->func_pointer_refcount
+= 1;
2207 /* If we are creating a shared library, and this is a reloc
2208 against a global symbol, or a non PC relative reloc
2209 against a local symbol, then we need to copy the reloc
2210 into the shared library. However, if we are linking with
2211 -Bsymbolic, we do not need to copy a reloc against a
2212 global symbol which is defined in an object we are
2213 including in the link (i.e., DEF_REGULAR is set). At
2214 this point we have not seen all the input files, so it is
2215 possible that DEF_REGULAR is not set now but will be set
2216 later (it is never cleared). In case of a weak definition,
2217 DEF_REGULAR may be cleared later by a strong definition in
2218 a shared library. We account for that possibility below by
2219 storing information in the relocs_copied field of the hash
2220 table entry. A similar situation occurs when creating
2221 shared libraries and symbol visibility changes render the
2224 If on the other hand, we are creating an executable, we
2225 may need to keep relocations for symbols satisfied by a
2226 dynamic library if we manage to avoid copy relocs for the
2229 Generate dynamic pointer relocation against STT_GNU_IFUNC
2230 symbol in the non-code section. */
2231 if ((bfd_link_pic (info
)
2232 && (r_type
!= R_386_PC32
2234 && (! (bfd_link_pie (info
)
2235 || SYMBOLIC_BIND (info
, h
))
2236 || h
->root
.type
== bfd_link_hash_defweak
2237 || !h
->def_regular
))))
2239 && h
->type
== STT_GNU_IFUNC
2240 && r_type
== R_386_32
2241 && (sec
->flags
& SEC_CODE
) == 0)
2242 || (ELIMINATE_COPY_RELOCS
2243 && !bfd_link_pic (info
)
2245 && (h
->root
.type
== bfd_link_hash_defweak
2246 || !h
->def_regular
)))
2248 struct elf_dyn_relocs
*p
;
2249 struct elf_dyn_relocs
**head
;
2251 /* We must copy these reloc types into the output file.
2252 Create a reloc section in dynobj and make room for
2256 if (htab
->elf
.dynobj
== NULL
)
2257 htab
->elf
.dynobj
= abfd
;
2259 sreloc
= _bfd_elf_make_dynamic_reloc_section
2260 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2266 /* If this is a global symbol, we count the number of
2267 relocations we need for this symbol. */
2270 head
= &eh
->dyn_relocs
;
2274 /* Track dynamic relocs needed for local syms too.
2275 We really need local syms available to do this
2280 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2285 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2289 vpp
= &elf_section_data (s
)->local_dynrel
;
2290 head
= (struct elf_dyn_relocs
**)vpp
;
2294 if (p
== NULL
|| p
->sec
!= sec
)
2296 bfd_size_type amt
= sizeof *p
;
2297 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2309 /* Count size relocation as PC-relative relocation. */
2310 if (r_type
== R_386_PC32
|| size_reloc
)
2315 /* This relocation describes the C++ object vtable hierarchy.
2316 Reconstruct it for later use during GC. */
2317 case R_386_GNU_VTINHERIT
:
2318 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2322 /* This relocation describes which C++ vtable entries are actually
2323 used. Record for later use during GC. */
2324 case R_386_GNU_VTENTRY
:
2325 BFD_ASSERT (h
!= NULL
);
2327 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2337 && h
->plt
.refcount
> 0
2338 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2339 || h
->got
.refcount
> 0)
2340 && htab
->plt_got
== NULL
)
2342 /* Create the GOT procedure linkage table. */
2343 unsigned int plt_got_align
;
2344 const struct elf_backend_data
*bed
;
2346 bed
= get_elf_backend_data (info
->output_bfd
);
2347 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
2348 && (sizeof (elf_i386_got_plt_entry
)
2349 == sizeof (elf_i386_pic_got_plt_entry
)));
2352 if (htab
->elf
.dynobj
== NULL
)
2353 htab
->elf
.dynobj
= abfd
;
2355 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2357 (bed
->dynamic_sec_flags
2362 if (htab
->plt_got
== NULL
2363 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2369 if (r_type
== R_386_GOT32X
2370 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2371 sec
->need_convert_load
= 1;
2374 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2376 if (!info
->keep_memory
)
2380 /* Cache the section contents for elf_link_input_bfd. */
2381 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2388 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2390 sec
->check_relocs_failed
= 1;
2394 /* Return the section that should be marked against GC for a given
2398 elf_i386_gc_mark_hook (asection
*sec
,
2399 struct bfd_link_info
*info
,
2400 Elf_Internal_Rela
*rel
,
2401 struct elf_link_hash_entry
*h
,
2402 Elf_Internal_Sym
*sym
)
2405 switch (ELF32_R_TYPE (rel
->r_info
))
2407 case R_386_GNU_VTINHERIT
:
2408 case R_386_GNU_VTENTRY
:
2412 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2415 /* Remove undefined weak symbol from the dynamic symbol table if it
2416 is resolved to 0. */
2419 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2420 struct elf_link_hash_entry
*h
)
2422 if (h
->dynindx
!= -1
2423 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2424 elf_i386_hash_entry (h
)->has_got_reloc
,
2425 elf_i386_hash_entry (h
)))
2428 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2434 /* Adjust a symbol defined by a dynamic object and referenced by a
2435 regular object. The current definition is in some section of the
2436 dynamic object, but we're not including those sections. We have to
2437 change the definition to something the rest of the link can
2441 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2442 struct elf_link_hash_entry
*h
)
2444 struct elf_i386_link_hash_table
*htab
;
2446 struct elf_i386_link_hash_entry
*eh
;
2447 struct elf_dyn_relocs
*p
;
2449 /* STT_GNU_IFUNC symbol must go through PLT. */
2450 if (h
->type
== STT_GNU_IFUNC
)
2452 /* All local STT_GNU_IFUNC references must be treate as local
2453 calls via local PLT. */
2455 && SYMBOL_CALLS_LOCAL (info
, h
))
2457 bfd_size_type pc_count
= 0, count
= 0;
2458 struct elf_dyn_relocs
**pp
;
2460 eh
= (struct elf_i386_link_hash_entry
*) h
;
2461 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2463 pc_count
+= p
->pc_count
;
2464 p
->count
-= p
->pc_count
;
2473 if (pc_count
|| count
)
2478 /* Increment PLT reference count only for PC-relative
2481 if (h
->plt
.refcount
<= 0)
2482 h
->plt
.refcount
= 1;
2484 h
->plt
.refcount
+= 1;
2489 if (h
->plt
.refcount
<= 0)
2491 h
->plt
.offset
= (bfd_vma
) -1;
2497 /* If this is a function, put it in the procedure linkage table. We
2498 will fill in the contents of the procedure linkage table later,
2499 when we know the address of the .got section. */
2500 if (h
->type
== STT_FUNC
2503 if (h
->plt
.refcount
<= 0
2504 || SYMBOL_CALLS_LOCAL (info
, h
)
2505 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2506 && h
->root
.type
== bfd_link_hash_undefweak
))
2508 /* This case can occur if we saw a PLT32 reloc in an input
2509 file, but the symbol was never referred to by a dynamic
2510 object, or if all references were garbage collected. In
2511 such a case, we don't actually need to build a procedure
2512 linkage table, and we can just do a PC32 reloc instead. */
2513 h
->plt
.offset
= (bfd_vma
) -1;
2520 /* It's possible that we incorrectly decided a .plt reloc was
2521 needed for an R_386_PC32 reloc to a non-function sym in
2522 check_relocs. We can't decide accurately between function and
2523 non-function syms in check-relocs; Objects loaded later in
2524 the link may change h->type. So fix it now. */
2525 h
->plt
.offset
= (bfd_vma
) -1;
2527 /* If this is a weak symbol, and there is a real definition, the
2528 processor independent code will have arranged for us to see the
2529 real definition first, and we can just use the same value. */
2530 if (h
->u
.weakdef
!= NULL
)
2532 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2533 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2534 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2535 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2536 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2537 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2541 /* This is a reference to a symbol defined by a dynamic object which
2542 is not a function. */
2544 /* If we are creating a shared library, we must presume that the
2545 only references to the symbol are via the global offset table.
2546 For such cases we need not do anything here; the relocations will
2547 be handled correctly by relocate_section. */
2548 if (!bfd_link_executable (info
))
2551 /* If there are no references to this symbol that do not use the
2552 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2554 eh
= (struct elf_i386_link_hash_entry
*) h
;
2555 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2558 /* If -z nocopyreloc was given, we won't generate them either. */
2559 if (info
->nocopyreloc
)
2565 htab
= elf_i386_hash_table (info
);
2569 /* If there aren't any dynamic relocs in read-only sections nor
2570 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2571 avoid the copy reloc. This doesn't work on VxWorks, where we can
2572 not have dynamic relocations (other than copy and jump slot
2573 relocations) in an executable. */
2574 if (ELIMINATE_COPY_RELOCS
2576 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2578 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2580 s
= p
->sec
->output_section
;
2581 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2592 /* We must allocate the symbol in our .dynbss section, which will
2593 become part of the .bss section of the executable. There will be
2594 an entry for this symbol in the .dynsym section. The dynamic
2595 object will contain position independent code, so all references
2596 from the dynamic object to this symbol will go through the global
2597 offset table. The dynamic linker will use the .dynsym entry to
2598 determine the address it must put in the global offset table, so
2599 both the dynamic object and the regular object will refer to the
2600 same memory location for the variable. */
2602 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2603 copy the initial value out of the dynamic object and into the
2604 runtime process image. */
2605 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2607 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2613 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2616 /* Allocate space in .plt, .got and associated reloc sections for
2620 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2622 struct bfd_link_info
*info
;
2623 struct elf_i386_link_hash_table
*htab
;
2624 struct elf_i386_link_hash_entry
*eh
;
2625 struct elf_dyn_relocs
*p
;
2626 unsigned plt_entry_size
;
2627 bfd_boolean resolved_to_zero
;
2629 if (h
->root
.type
== bfd_link_hash_indirect
)
2632 eh
= (struct elf_i386_link_hash_entry
*) h
;
2634 info
= (struct bfd_link_info
*) inf
;
2635 htab
= elf_i386_hash_table (info
);
2639 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2641 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2645 /* Clear the reference count of function pointer relocations if
2646 symbol isn't a normal function. */
2647 if (h
->type
!= STT_FUNC
)
2648 eh
->func_pointer_refcount
= 0;
2650 /* We can't use the GOT PLT if pointer equality is needed since
2651 finish_dynamic_symbol won't clear symbol value and the dynamic
2652 linker won't update the GOT slot. We will get into an infinite
2653 loop at run-time. */
2654 if (htab
->plt_got
!= NULL
2655 && h
->type
!= STT_GNU_IFUNC
2656 && !h
->pointer_equality_needed
2657 && h
->plt
.refcount
> 0
2658 && h
->got
.refcount
> 0)
2660 /* Don't use the regular PLT if there are both GOT and GOTPLT
2662 h
->plt
.offset
= (bfd_vma
) -1;
2664 /* Use the GOT PLT. */
2665 eh
->plt_got
.refcount
= 1;
2668 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2669 here if it is defined and referenced in a non-shared object. */
2670 if (h
->type
== STT_GNU_IFUNC
2672 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2673 &htab
->readonly_dynrelocs_against_ifunc
,
2675 plt_entry_size
, 4, TRUE
);
2676 /* Don't create the PLT entry if there are only function pointer
2677 relocations which can be resolved at run-time. */
2678 else if (htab
->elf
.dynamic_sections_created
2679 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2680 || eh
->plt_got
.refcount
> 0))
2682 bfd_boolean use_plt_got
;
2684 /* Clear the reference count of function pointer relocations
2686 eh
->func_pointer_refcount
= 0;
2688 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2690 /* Don't use the regular PLT for DF_BIND_NOW. */
2691 h
->plt
.offset
= (bfd_vma
) -1;
2693 /* Use the GOT PLT. */
2694 h
->got
.refcount
= 1;
2695 eh
->plt_got
.refcount
= 1;
2698 use_plt_got
= eh
->plt_got
.refcount
> 0;
2700 /* Make sure this symbol is output as a dynamic symbol.
2701 Undefined weak syms won't yet be marked as dynamic. */
2702 if (h
->dynindx
== -1
2704 && !resolved_to_zero
)
2706 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2710 if (bfd_link_pic (info
)
2711 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2713 asection
*s
= htab
->elf
.splt
;
2714 asection
*got_s
= htab
->plt_got
;
2716 /* If this is the first .plt entry, make room for the special
2717 first entry. The .plt section is used by prelink to undo
2718 prelinking for dynamic relocations. */
2720 s
->size
= plt_entry_size
;
2723 eh
->plt_got
.offset
= got_s
->size
;
2725 h
->plt
.offset
= s
->size
;
2727 /* If this symbol is not defined in a regular file, and we are
2728 not generating a shared library, then set the symbol to this
2729 location in the .plt. This is required to make function
2730 pointers compare as equal between the normal executable and
2731 the shared library. */
2732 if (! bfd_link_pic (info
)
2737 /* We need to make a call to the entry of the GOT PLT
2738 instead of regular PLT entry. */
2739 h
->root
.u
.def
.section
= got_s
;
2740 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2744 h
->root
.u
.def
.section
= s
;
2745 h
->root
.u
.def
.value
= h
->plt
.offset
;
2749 /* Make room for this entry. */
2751 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2754 s
->size
+= plt_entry_size
;
2756 /* We also need to make an entry in the .got.plt section,
2757 which will be placed in the .got section by the linker
2759 htab
->elf
.sgotplt
->size
+= 4;
2761 /* There should be no PLT relocation against resolved
2762 undefined weak symbol in executable. */
2763 if (!resolved_to_zero
)
2765 /* We also need to make an entry in the .rel.plt
2767 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2768 htab
->elf
.srelplt
->reloc_count
++;
2772 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2773 && !bfd_link_pic (info
))
2775 /* VxWorks has a second set of relocations for each PLT entry
2776 in executables. They go in a separate relocation section,
2777 which is processed by the kernel loader. */
2779 /* There are two relocations for the initial PLT entry: an
2780 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2781 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2783 if (h
->plt
.offset
== plt_entry_size
)
2784 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2786 /* There are two extra relocations for each subsequent PLT entry:
2787 an R_386_32 relocation for the GOT entry, and an R_386_32
2788 relocation for the PLT entry. */
2790 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2795 eh
->plt_got
.offset
= (bfd_vma
) -1;
2796 h
->plt
.offset
= (bfd_vma
) -1;
2802 eh
->plt_got
.offset
= (bfd_vma
) -1;
2803 h
->plt
.offset
= (bfd_vma
) -1;
2807 eh
->tlsdesc_got
= (bfd_vma
) -1;
2809 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2810 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2811 if (h
->got
.refcount
> 0
2812 && bfd_link_executable (info
)
2814 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2815 h
->got
.offset
= (bfd_vma
) -1;
2816 else if (h
->got
.refcount
> 0)
2820 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2822 /* Make sure this symbol is output as a dynamic symbol.
2823 Undefined weak syms won't yet be marked as dynamic. */
2824 if (h
->dynindx
== -1
2826 && !resolved_to_zero
)
2828 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2833 if (GOT_TLS_GDESC_P (tls_type
))
2835 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2836 - elf_i386_compute_jump_table_size (htab
);
2837 htab
->elf
.sgotplt
->size
+= 8;
2838 h
->got
.offset
= (bfd_vma
) -2;
2840 if (! GOT_TLS_GDESC_P (tls_type
)
2841 || GOT_TLS_GD_P (tls_type
))
2843 h
->got
.offset
= s
->size
;
2845 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2846 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2849 dyn
= htab
->elf
.dynamic_sections_created
;
2850 /* R_386_TLS_IE_32 needs one dynamic relocation,
2851 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2852 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2853 need two), R_386_TLS_GD needs one if local symbol and two if
2854 global. No dynamic relocation against resolved undefined weak
2855 symbol in executable. */
2856 if (tls_type
== GOT_TLS_IE_BOTH
)
2857 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2858 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2859 || (tls_type
& GOT_TLS_IE
))
2860 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2861 else if (GOT_TLS_GD_P (tls_type
))
2862 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2863 else if (! GOT_TLS_GDESC_P (tls_type
)
2864 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2865 && !resolved_to_zero
)
2866 || h
->root
.type
!= bfd_link_hash_undefweak
)
2867 && (bfd_link_pic (info
)
2868 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2869 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2870 if (GOT_TLS_GDESC_P (tls_type
))
2871 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2874 h
->got
.offset
= (bfd_vma
) -1;
2876 if (eh
->dyn_relocs
== NULL
)
2879 /* In the shared -Bsymbolic case, discard space allocated for
2880 dynamic pc-relative relocs against symbols which turn out to be
2881 defined in regular objects. For the normal shared case, discard
2882 space for pc-relative relocs that have become local due to symbol
2883 visibility changes. */
2885 if (bfd_link_pic (info
))
2887 /* The only reloc that uses pc_count is R_386_PC32, which will
2888 appear on a call or on something like ".long foo - .". We
2889 want calls to protected symbols to resolve directly to the
2890 function rather than going via the plt. If people want
2891 function pointer comparisons to work as expected then they
2892 should avoid writing assembly like ".long foo - .". */
2893 if (SYMBOL_CALLS_LOCAL (info
, h
))
2895 struct elf_dyn_relocs
**pp
;
2897 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2899 p
->count
-= p
->pc_count
;
2908 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2910 struct elf_dyn_relocs
**pp
;
2911 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2913 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2920 /* Also discard relocs on undefined weak syms with non-default
2921 visibility or in PIE. */
2922 if (eh
->dyn_relocs
!= NULL
2923 && h
->root
.type
== bfd_link_hash_undefweak
)
2925 /* Undefined weak symbol is never bound locally in shared
2927 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2928 || resolved_to_zero
)
2932 /* Keep dynamic non-GOT/non-PLT relocation so that we
2933 can branch to 0 without PLT. */
2934 struct elf_dyn_relocs
**pp
;
2936 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2937 if (p
->pc_count
== 0)
2941 /* Remove non-R_386_PC32 relocation. */
2942 p
->count
= p
->pc_count
;
2946 if (eh
->dyn_relocs
!= NULL
)
2948 /* Make sure undefined weak symbols are output
2949 as dynamic symbols in PIEs for dynamic non-GOT
2950 non-PLT reloations. */
2951 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2956 eh
->dyn_relocs
= NULL
;
2958 else if (h
->dynindx
== -1
2959 && !h
->forced_local
)
2961 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2966 else if (ELIMINATE_COPY_RELOCS
)
2968 /* For the non-shared case, discard space for relocs against
2969 symbols which turn out to need copy relocs or are not
2970 dynamic. Keep dynamic relocations for run-time function
2971 pointer initialization. */
2973 if ((!h
->non_got_ref
2974 || eh
->func_pointer_refcount
> 0
2975 || (h
->root
.type
== bfd_link_hash_undefweak
2976 && !resolved_to_zero
))
2979 || (htab
->elf
.dynamic_sections_created
2980 && (h
->root
.type
== bfd_link_hash_undefweak
2981 || h
->root
.type
== bfd_link_hash_undefined
))))
2983 /* Make sure this symbol is output as a dynamic symbol.
2984 Undefined weak syms won't yet be marked as dynamic. */
2985 if (h
->dynindx
== -1
2987 && !resolved_to_zero
)
2989 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2993 /* If that succeeded, we know we'll be keeping all the
2995 if (h
->dynindx
!= -1)
2999 eh
->dyn_relocs
= NULL
;
3000 eh
->func_pointer_refcount
= 0;
3005 /* Finally, allocate space. */
3006 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3010 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3012 BFD_ASSERT (sreloc
!= NULL
);
3013 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3019 /* Allocate space in .plt, .got and associated reloc sections for
3020 local dynamic relocs. */
3023 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
3025 struct elf_link_hash_entry
*h
3026 = (struct elf_link_hash_entry
*) *slot
;
3028 if (h
->type
!= STT_GNU_IFUNC
3032 || h
->root
.type
!= bfd_link_hash_defined
)
3035 return elf_i386_allocate_dynrelocs (h
, inf
);
3038 /* Find any dynamic relocs that apply to read-only sections. */
3041 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3043 struct elf_i386_link_hash_entry
*eh
;
3044 struct elf_dyn_relocs
*p
;
3046 /* Skip local IFUNC symbols. */
3047 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3050 eh
= (struct elf_i386_link_hash_entry
*) h
;
3051 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3053 asection
*s
= p
->sec
->output_section
;
3055 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3057 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3059 info
->flags
|= DF_TEXTREL
;
3061 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3062 || info
->error_textrel
)
3063 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3064 p
->sec
->owner
, h
->root
.root
.string
,
3067 /* Not an error, just cut short the traversal. */
3074 /* Convert load via the GOT slot to load immediate. */
3077 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
3078 struct bfd_link_info
*link_info
)
3080 struct elf_i386_link_hash_table
*htab
;
3081 Elf_Internal_Shdr
*symtab_hdr
;
3082 Elf_Internal_Rela
*internal_relocs
;
3083 Elf_Internal_Rela
*irel
, *irelend
;
3085 bfd_boolean changed
;
3086 bfd_signed_vma
*local_got_refcounts
;
3088 /* Don't even try to convert non-ELF outputs. */
3089 if (!is_elf_hash_table (link_info
->hash
))
3092 /* Nothing to do if there is no need or no output. */
3093 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3094 || sec
->need_convert_load
== 0
3095 || bfd_is_abs_section (sec
->output_section
))
3098 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3100 /* Load the relocations for this section. */
3101 internal_relocs
= (_bfd_elf_link_read_relocs
3102 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3103 link_info
->keep_memory
));
3104 if (internal_relocs
== NULL
)
3108 htab
= elf_i386_hash_table (link_info
);
3109 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3111 /* Get the section contents. */
3112 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3113 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3116 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3120 irelend
= internal_relocs
+ sec
->reloc_count
;
3121 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3123 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3124 unsigned int r_symndx
;
3125 struct elf_link_hash_entry
*h
;
3126 bfd_boolean converted
;
3128 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3129 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3130 if (r_type
!= R_386_GOT32X
)
3133 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3134 if (r_symndx
< symtab_hdr
->sh_info
)
3135 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3136 (const Elf_Internal_Rela
*) irel
,
3140 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3141 while (h
->root
.type
== bfd_link_hash_indirect
3142 || h
->root
.type
== bfd_link_hash_warning
)
3143 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3146 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3147 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3151 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3152 irel
, h
, &converted
, link_info
))
3157 changed
= converted
;
3160 if (h
->got
.refcount
> 0)
3161 h
->got
.refcount
-= 1;
3165 if (local_got_refcounts
!= NULL
3166 && local_got_refcounts
[r_symndx
] > 0)
3167 local_got_refcounts
[r_symndx
] -= 1;
3172 if (contents
!= NULL
3173 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3175 if (!changed
&& !link_info
->keep_memory
)
3179 /* Cache the section contents for elf_link_input_bfd. */
3180 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3184 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3187 free (internal_relocs
);
3189 elf_section_data (sec
)->relocs
= internal_relocs
;
3195 if (contents
!= NULL
3196 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3198 if (internal_relocs
!= NULL
3199 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3200 free (internal_relocs
);
3204 /* Set the sizes of the dynamic sections. */
3207 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3209 struct elf_i386_link_hash_table
*htab
;
3215 htab
= elf_i386_hash_table (info
);
3218 dynobj
= htab
->elf
.dynobj
;
3222 /* Set up .got offsets for local syms, and space for local dynamic
3224 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3226 bfd_signed_vma
*local_got
;
3227 bfd_signed_vma
*end_local_got
;
3228 char *local_tls_type
;
3229 bfd_vma
*local_tlsdesc_gotent
;
3230 bfd_size_type locsymcount
;
3231 Elf_Internal_Shdr
*symtab_hdr
;
3234 if (! is_i386_elf (ibfd
))
3237 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3239 struct elf_dyn_relocs
*p
;
3241 if (!elf_i386_convert_load (ibfd
, s
, info
))
3244 for (p
= ((struct elf_dyn_relocs
*)
3245 elf_section_data (s
)->local_dynrel
);
3249 if (!bfd_is_abs_section (p
->sec
)
3250 && bfd_is_abs_section (p
->sec
->output_section
))
3252 /* Input section has been discarded, either because
3253 it is a copy of a linkonce section or due to
3254 linker script /DISCARD/, so we'll be discarding
3257 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3258 && strcmp (p
->sec
->output_section
->name
,
3261 /* Relocations in vxworks .tls_vars sections are
3262 handled specially by the loader. */
3264 else if (p
->count
!= 0)
3266 srel
= elf_section_data (p
->sec
)->sreloc
;
3267 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3268 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3269 && (info
->flags
& DF_TEXTREL
) == 0)
3271 info
->flags
|= DF_TEXTREL
;
3272 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3273 || info
->error_textrel
)
3274 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3275 p
->sec
->owner
, p
->sec
);
3281 local_got
= elf_local_got_refcounts (ibfd
);
3285 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3286 locsymcount
= symtab_hdr
->sh_info
;
3287 end_local_got
= local_got
+ locsymcount
;
3288 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3289 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3291 srel
= htab
->elf
.srelgot
;
3292 for (; local_got
< end_local_got
;
3293 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3295 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3298 if (GOT_TLS_GDESC_P (*local_tls_type
))
3300 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3301 - elf_i386_compute_jump_table_size (htab
);
3302 htab
->elf
.sgotplt
->size
+= 8;
3303 *local_got
= (bfd_vma
) -2;
3305 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3306 || GOT_TLS_GD_P (*local_tls_type
))
3308 *local_got
= s
->size
;
3310 if (GOT_TLS_GD_P (*local_tls_type
)
3311 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3314 if (bfd_link_pic (info
)
3315 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3316 || (*local_tls_type
& GOT_TLS_IE
))
3318 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3319 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3320 else if (GOT_TLS_GD_P (*local_tls_type
)
3321 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3322 srel
->size
+= sizeof (Elf32_External_Rel
);
3323 if (GOT_TLS_GDESC_P (*local_tls_type
))
3324 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3328 *local_got
= (bfd_vma
) -1;
3332 if (htab
->tls_ldm_got
.refcount
> 0)
3334 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3336 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3337 htab
->elf
.sgot
->size
+= 8;
3338 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3341 htab
->tls_ldm_got
.offset
= -1;
3343 /* Allocate global sym .plt and .got entries, and space for global
3344 sym dynamic relocs. */
3345 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3347 /* Allocate .plt and .got entries, and space for local symbols. */
3348 htab_traverse (htab
->loc_hash_table
,
3349 elf_i386_allocate_local_dynrelocs
,
3352 /* For every jump slot reserved in the sgotplt, reloc_count is
3353 incremented. However, when we reserve space for TLS descriptors,
3354 it's not incremented, so in order to compute the space reserved
3355 for them, it suffices to multiply the reloc count by the jump
3358 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3359 so that R_386_IRELATIVE entries come last. */
3360 if (htab
->elf
.srelplt
)
3362 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3363 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3364 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3366 else if (htab
->elf
.irelplt
)
3367 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3370 if (htab
->elf
.sgotplt
)
3372 /* Don't allocate .got.plt section if there are no GOT nor PLT
3373 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3374 if ((htab
->elf
.hgot
== NULL
3375 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3376 && (htab
->elf
.sgotplt
->size
3377 == get_elf_backend_data (output_bfd
)->got_header_size
)
3378 && (htab
->elf
.splt
== NULL
3379 || htab
->elf
.splt
->size
== 0)
3380 && (htab
->elf
.sgot
== NULL
3381 || htab
->elf
.sgot
->size
== 0)
3382 && (htab
->elf
.iplt
== NULL
3383 || htab
->elf
.iplt
->size
== 0)
3384 && (htab
->elf
.igotplt
== NULL
3385 || htab
->elf
.igotplt
->size
== 0))
3386 htab
->elf
.sgotplt
->size
= 0;
3390 if (htab
->plt_eh_frame
!= NULL
3391 && htab
->elf
.splt
!= NULL
3392 && htab
->elf
.splt
->size
!= 0
3393 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3394 && _bfd_elf_eh_frame_present (info
))
3395 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3397 /* We now have determined the sizes of the various dynamic sections.
3398 Allocate memory for them. */
3400 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3402 bfd_boolean strip_section
= TRUE
;
3404 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3407 if (s
== htab
->elf
.splt
3408 || s
== htab
->elf
.sgot
)
3410 /* Strip this section if we don't need it; see the
3412 /* We'd like to strip these sections if they aren't needed, but if
3413 we've exported dynamic symbols from them we must leave them.
3414 It's too late to tell BFD to get rid of the symbols. */
3416 if (htab
->elf
.hplt
!= NULL
)
3417 strip_section
= FALSE
;
3419 else if (s
== htab
->elf
.sgotplt
3420 || s
== htab
->elf
.iplt
3421 || s
== htab
->elf
.igotplt
3422 || s
== htab
->plt_got
3423 || s
== htab
->plt_eh_frame
3424 || s
== htab
->sdynbss
)
3426 /* Strip these too. */
3428 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3431 && s
!= htab
->elf
.srelplt
3432 && s
!= htab
->srelplt2
)
3435 /* We use the reloc_count field as a counter if we need
3436 to copy relocs into the output file. */
3441 /* It's not one of our sections, so don't allocate space. */
3447 /* If we don't need this section, strip it from the
3448 output file. This is mostly to handle .rel.bss and
3449 .rel.plt. We must create both sections in
3450 create_dynamic_sections, because they must be created
3451 before the linker maps input sections to output
3452 sections. The linker does that before
3453 adjust_dynamic_symbol is called, and it is that
3454 function which decides whether anything needs to go
3455 into these sections. */
3457 s
->flags
|= SEC_EXCLUDE
;
3461 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3464 /* Allocate memory for the section contents. We use bfd_zalloc
3465 here in case unused entries are not reclaimed before the
3466 section's contents are written out. This should not happen,
3467 but this way if it does, we get a R_386_NONE reloc instead
3469 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3470 if (s
->contents
== NULL
)
3474 if (htab
->plt_eh_frame
!= NULL
3475 && htab
->plt_eh_frame
->contents
!= NULL
)
3477 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3478 sizeof (elf_i386_eh_frame_plt
));
3479 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3480 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3483 if (htab
->elf
.dynamic_sections_created
)
3485 /* Add some entries to the .dynamic section. We fill in the
3486 values later, in elf_i386_finish_dynamic_sections, but we
3487 must add the entries now so that we get the correct size for
3488 the .dynamic section. The DT_DEBUG entry is filled in by the
3489 dynamic linker and used by the debugger. */
3490 #define add_dynamic_entry(TAG, VAL) \
3491 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3493 if (bfd_link_executable (info
))
3495 if (!add_dynamic_entry (DT_DEBUG
, 0))
3499 if (htab
->elf
.splt
->size
!= 0)
3501 /* DT_PLTGOT is used by prelink even if there is no PLT
3503 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3506 if (htab
->elf
.srelplt
->size
!= 0)
3508 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3509 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3510 || !add_dynamic_entry (DT_JMPREL
, 0))
3517 if (!add_dynamic_entry (DT_REL
, 0)
3518 || !add_dynamic_entry (DT_RELSZ
, 0)
3519 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3522 /* If any dynamic relocs apply to a read-only section,
3523 then we need a DT_TEXTREL entry. */
3524 if ((info
->flags
& DF_TEXTREL
) == 0)
3525 elf_link_hash_traverse (&htab
->elf
,
3526 elf_i386_readonly_dynrelocs
, info
);
3528 if ((info
->flags
& DF_TEXTREL
) != 0)
3530 if (htab
->readonly_dynrelocs_against_ifunc
)
3532 info
->callbacks
->einfo
3533 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3534 bfd_set_error (bfd_error_bad_value
);
3538 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3542 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3543 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3546 #undef add_dynamic_entry
3552 elf_i386_always_size_sections (bfd
*output_bfd
,
3553 struct bfd_link_info
*info
)
3555 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3559 struct elf_link_hash_entry
*tlsbase
;
3561 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3562 "_TLS_MODULE_BASE_",
3563 FALSE
, FALSE
, FALSE
);
3565 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3567 struct elf_i386_link_hash_table
*htab
;
3568 struct bfd_link_hash_entry
*bh
= NULL
;
3569 const struct elf_backend_data
*bed
3570 = get_elf_backend_data (output_bfd
);
3572 htab
= elf_i386_hash_table (info
);
3576 if (!(_bfd_generic_link_add_one_symbol
3577 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3578 tls_sec
, 0, NULL
, FALSE
,
3579 bed
->collect
, &bh
)))
3582 htab
->tls_module_base
= bh
;
3584 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3585 tlsbase
->def_regular
= 1;
3586 tlsbase
->other
= STV_HIDDEN
;
3587 tlsbase
->root
.linker_def
= 1;
3588 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3595 /* Set the correct type for an x86 ELF section. We do this by the
3596 section name, which is a hack, but ought to work. */
3599 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3600 Elf_Internal_Shdr
*hdr
,
3605 name
= bfd_get_section_name (abfd
, sec
);
3607 /* This is an ugly, but unfortunately necessary hack that is
3608 needed when producing EFI binaries on x86. It tells
3609 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3610 containing ELF relocation info. We need this hack in order to
3611 be able to generate ELF binaries that can be translated into
3612 EFI applications (which are essentially COFF objects). Those
3613 files contain a COFF ".reloc" section inside an ELFNN object,
3614 which would normally cause BFD to segfault because it would
3615 attempt to interpret this section as containing relocation
3616 entries for section "oc". With this hack enabled, ".reloc"
3617 will be treated as a normal data section, which will avoid the
3618 segfault. However, you won't be able to create an ELFNN binary
3619 with a section named "oc" that needs relocations, but that's
3620 the kind of ugly side-effects you get when detecting section
3621 types based on their names... In practice, this limitation is
3622 unlikely to bite. */
3623 if (strcmp (name
, ".reloc") == 0)
3624 hdr
->sh_type
= SHT_PROGBITS
;
3629 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3630 executables. Rather than setting it to the beginning of the TLS
3631 section, we have to set it to the end. This function may be called
3632 multiple times, it is idempotent. */
3635 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3637 struct elf_i386_link_hash_table
*htab
;
3638 struct bfd_link_hash_entry
*base
;
3640 if (!bfd_link_executable (info
))
3643 htab
= elf_i386_hash_table (info
);
3647 base
= htab
->tls_module_base
;
3651 base
->u
.def
.value
= htab
->elf
.tls_size
;
3654 /* Return the base VMA address which should be subtracted from real addresses
3655 when resolving @dtpoff relocation.
3656 This is PT_TLS segment p_vaddr. */
3659 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3661 /* If tls_sec is NULL, we should have signalled an error already. */
3662 if (elf_hash_table (info
)->tls_sec
== NULL
)
3664 return elf_hash_table (info
)->tls_sec
->vma
;
3667 /* Return the relocation value for @tpoff relocation
3668 if STT_TLS virtual address is ADDRESS. */
3671 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3673 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3674 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3675 bfd_vma static_tls_size
;
3677 /* If tls_sec is NULL, we should have signalled an error already. */
3678 if (htab
->tls_sec
== NULL
)
3681 /* Consider special static TLS alignment requirements. */
3682 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3683 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3686 /* Relocate an i386 ELF section. */
3689 elf_i386_relocate_section (bfd
*output_bfd
,
3690 struct bfd_link_info
*info
,
3692 asection
*input_section
,
3694 Elf_Internal_Rela
*relocs
,
3695 Elf_Internal_Sym
*local_syms
,
3696 asection
**local_sections
)
3698 struct elf_i386_link_hash_table
*htab
;
3699 Elf_Internal_Shdr
*symtab_hdr
;
3700 struct elf_link_hash_entry
**sym_hashes
;
3701 bfd_vma
*local_got_offsets
;
3702 bfd_vma
*local_tlsdesc_gotents
;
3703 Elf_Internal_Rela
*rel
;
3704 Elf_Internal_Rela
*wrel
;
3705 Elf_Internal_Rela
*relend
;
3706 bfd_boolean is_vxworks_tls
;
3707 unsigned plt_entry_size
;
3709 BFD_ASSERT (is_i386_elf (input_bfd
));
3711 /* Skip if check_relocs failed. */
3712 if (input_section
->check_relocs_failed
)
3715 htab
= elf_i386_hash_table (info
);
3718 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3719 sym_hashes
= elf_sym_hashes (input_bfd
);
3720 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3721 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3722 /* We have to handle relocations in vxworks .tls_vars sections
3723 specially, because the dynamic loader is 'weird'. */
3724 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3725 && bfd_link_pic (info
)
3726 && !strcmp (input_section
->output_section
->name
,
3729 elf_i386_set_tls_module_base (info
);
3731 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3733 rel
= wrel
= relocs
;
3734 relend
= relocs
+ input_section
->reloc_count
;
3735 for (; rel
< relend
; wrel
++, rel
++)
3737 unsigned int r_type
;
3738 reloc_howto_type
*howto
;
3739 unsigned long r_symndx
;
3740 struct elf_link_hash_entry
*h
;
3741 struct elf_i386_link_hash_entry
*eh
;
3742 Elf_Internal_Sym
*sym
;
3744 bfd_vma off
, offplt
, plt_offset
;
3746 bfd_boolean unresolved_reloc
;
3747 bfd_reloc_status_type r
;
3751 asection
*resolved_plt
;
3752 bfd_boolean resolved_to_zero
;
3754 r_type
= ELF32_R_TYPE (rel
->r_info
);
3755 if (r_type
== R_386_GNU_VTINHERIT
3756 || r_type
== R_386_GNU_VTENTRY
)
3763 if ((indx
= r_type
) >= R_386_standard
3764 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3765 >= R_386_ext
- R_386_standard
)
3766 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3767 >= R_386_ext2
- R_386_ext
))
3770 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3771 input_bfd
, input_section
, r_type
);
3772 bfd_set_error (bfd_error_bad_value
);
3775 howto
= elf_howto_table
+ indx
;
3777 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3781 unresolved_reloc
= FALSE
;
3782 if (r_symndx
< symtab_hdr
->sh_info
)
3784 sym
= local_syms
+ r_symndx
;
3785 sec
= local_sections
[r_symndx
];
3786 relocation
= (sec
->output_section
->vma
3787 + sec
->output_offset
3789 st_size
= sym
->st_size
;
3791 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3792 && ((sec
->flags
& SEC_MERGE
) != 0
3793 || (bfd_link_relocatable (info
)
3794 && sec
->output_offset
!= 0)))
3797 bfd_byte
*where
= contents
+ rel
->r_offset
;
3799 switch (howto
->size
)
3802 addend
= bfd_get_8 (input_bfd
, where
);
3803 if (howto
->pc_relative
)
3805 addend
= (addend
^ 0x80) - 0x80;
3810 addend
= bfd_get_16 (input_bfd
, where
);
3811 if (howto
->pc_relative
)
3813 addend
= (addend
^ 0x8000) - 0x8000;
3818 addend
= bfd_get_32 (input_bfd
, where
);
3819 if (howto
->pc_relative
)
3821 addend
= (addend
^ 0x80000000) - 0x80000000;
3829 if (bfd_link_relocatable (info
))
3830 addend
+= sec
->output_offset
;
3833 asection
*msec
= sec
;
3834 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3836 addend
-= relocation
;
3837 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3840 switch (howto
->size
)
3843 /* FIXME: overflow checks. */
3844 if (howto
->pc_relative
)
3846 bfd_put_8 (input_bfd
, addend
, where
);
3849 if (howto
->pc_relative
)
3851 bfd_put_16 (input_bfd
, addend
, where
);
3854 if (howto
->pc_relative
)
3856 bfd_put_32 (input_bfd
, addend
, where
);
3860 else if (!bfd_link_relocatable (info
)
3861 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3863 /* Relocate against local STT_GNU_IFUNC symbol. */
3864 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3869 /* Set STT_GNU_IFUNC symbol value. */
3870 h
->root
.u
.def
.value
= sym
->st_value
;
3871 h
->root
.u
.def
.section
= sec
;
3876 bfd_boolean warned ATTRIBUTE_UNUSED
;
3877 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3879 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3880 r_symndx
, symtab_hdr
, sym_hashes
,
3882 unresolved_reloc
, warned
, ignored
);
3886 if (sec
!= NULL
&& discarded_section (sec
))
3888 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3889 contents
+ rel
->r_offset
);
3890 wrel
->r_offset
= rel
->r_offset
;
3894 /* For ld -r, remove relocations in debug sections against
3895 sections defined in discarded sections. Not done for
3896 eh_frame editing code expects to be present. */
3897 if (bfd_link_relocatable (info
)
3898 && (input_section
->flags
& SEC_DEBUGGING
))
3904 if (bfd_link_relocatable (info
))
3911 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3912 it here if it is defined in a non-shared object. */
3914 && h
->type
== STT_GNU_IFUNC
3917 asection
*plt
, *gotplt
, *base_got
;
3921 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3923 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3924 sections because such sections are not SEC_ALLOC and
3925 thus ld.so will not process them. */
3926 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3931 /* STT_GNU_IFUNC symbol must go through PLT. */
3932 if (htab
->elf
.splt
!= NULL
)
3934 plt
= htab
->elf
.splt
;
3935 gotplt
= htab
->elf
.sgotplt
;
3939 plt
= htab
->elf
.iplt
;
3940 gotplt
= htab
->elf
.igotplt
;
3950 base_got
= htab
->elf
.sgot
;
3951 off
= h
->got
.offset
;
3953 if (base_got
== NULL
)
3956 if (off
== (bfd_vma
) -1)
3958 /* We can't use h->got.offset here to save state, or
3959 even just remember the offset, as finish_dynamic_symbol
3960 would use that as offset into .got. */
3962 if (h
->plt
.offset
== (bfd_vma
) -1)
3965 if (htab
->elf
.splt
!= NULL
)
3967 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3968 off
= (plt_index
+ 3) * 4;
3969 base_got
= htab
->elf
.sgotplt
;
3973 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3974 off
= plt_index
* 4;
3975 base_got
= htab
->elf
.igotplt
;
3978 if (h
->dynindx
== -1
3982 /* This references the local defitionion. We must
3983 initialize this entry in the global offset table.
3984 Since the offset must always be a multiple of 8,
3985 we use the least significant bit to record
3986 whether we have initialized it already.
3988 When doing a dynamic link, we create a .rela.got
3989 relocation entry to initialize the value. This
3990 is done in the finish_dynamic_symbol routine. */
3995 bfd_put_32 (output_bfd
, relocation
,
3996 base_got
->contents
+ off
);
4004 relocation
= (base_got
->output_section
->vma
4005 + base_got
->output_offset
+ off
4006 - gotplt
->output_section
->vma
4007 - gotplt
->output_offset
);
4009 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4011 if (bfd_link_pic (info
))
4012 goto disallow_got32
;
4014 /* Add the GOT base if there is no base register. */
4015 relocation
+= (gotplt
->output_section
->vma
4016 + gotplt
->output_offset
);
4018 else if (htab
->elf
.splt
== NULL
)
4020 /* Adjust for static executables. */
4021 relocation
+= gotplt
->output_offset
;
4027 if (h
->plt
.offset
== (bfd_vma
) -1)
4029 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4030 if (r_type
== R_386_32
4031 && (input_section
->flags
& SEC_CODE
) == 0)
4032 goto do_ifunc_pointer
;
4033 goto bad_ifunc_reloc
;
4036 relocation
= (plt
->output_section
->vma
4037 + plt
->output_offset
+ h
->plt
.offset
);
4043 if (h
->root
.root
.string
)
4044 name
= h
->root
.root
.string
;
4046 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4049 (_("%B: relocation %s against STT_GNU_IFUNC "
4050 "symbol `%s' isn't supported"), input_bfd
,
4052 bfd_set_error (bfd_error_bad_value
);
4056 /* Generate dynamic relcoation only when there is a
4057 non-GOT reference in a shared object. */
4058 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4059 || h
->plt
.offset
== (bfd_vma
) -1)
4061 Elf_Internal_Rela outrel
;
4066 /* Need a dynamic relocation to get the real function
4068 offset
= _bfd_elf_section_offset (output_bfd
,
4072 if (offset
== (bfd_vma
) -1
4073 || offset
== (bfd_vma
) -2)
4076 outrel
.r_offset
= (input_section
->output_section
->vma
4077 + input_section
->output_offset
4080 if (h
->dynindx
== -1
4082 || bfd_link_executable (info
))
4084 /* This symbol is resolved locally. */
4085 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4086 bfd_put_32 (output_bfd
,
4087 (h
->root
.u
.def
.value
4088 + h
->root
.u
.def
.section
->output_section
->vma
4089 + h
->root
.u
.def
.section
->output_offset
),
4093 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4095 /* Dynamic relocations are stored in
4096 1. .rel.ifunc section in PIC object.
4097 2. .rel.got section in dynamic executable.
4098 3. .rel.iplt section in static executable. */
4099 if (bfd_link_pic (info
))
4100 sreloc
= htab
->elf
.irelifunc
;
4101 else if (htab
->elf
.splt
!= NULL
)
4102 sreloc
= htab
->elf
.srelgot
;
4104 sreloc
= htab
->elf
.irelplt
;
4105 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4107 /* If this reloc is against an external symbol, we
4108 do not want to fiddle with the addend. Otherwise,
4109 we need to include the symbol value so that it
4110 becomes an addend for the dynamic reloc. For an
4111 internal symbol, we have updated addend. */
4120 relocation
-= (gotplt
->output_section
->vma
4121 + gotplt
->output_offset
);
4126 eh
= (struct elf_i386_link_hash_entry
*) h
;
4127 resolved_to_zero
= (eh
!= NULL
4128 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4135 /* Avoid optimizing _DYNAMIC since ld.so may use its
4136 link-time address. */
4137 if (h
== htab
->elf
.hdynamic
)
4140 if (bfd_link_pic (info
))
4142 /* It is OK to convert mov to lea and convert indirect
4143 branch to direct branch. It is OK to convert adc,
4144 add, and, cmp, or, sbb, sub, test, xor only when PIC
4146 unsigned int opcode
, addend
;
4147 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4150 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4151 if (opcode
!= 0x8b && opcode
!= 0xff)
4155 /* Resolve "mov GOT[(%reg)], %reg",
4156 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4157 and "binop foo@GOT[(%reg)], %reg". */
4159 || (h
->plt
.offset
== (bfd_vma
) -1
4160 && h
->got
.offset
== (bfd_vma
) -1)
4161 || htab
->elf
.sgotplt
== NULL
)
4164 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4165 + htab
->elf
.sgotplt
->output_offset
);
4167 /* It is relative to .got.plt section. */
4168 if (h
->got
.offset
!= (bfd_vma
) -1)
4169 /* Use GOT entry. Mask off the least significant bit in
4170 GOT offset which may be set by R_386_GOT32 processing
4172 relocation
= (htab
->elf
.sgot
->output_section
->vma
4173 + htab
->elf
.sgot
->output_offset
4174 + (h
->got
.offset
& ~1) - offplt
);
4176 /* Use GOTPLT entry. */
4177 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4179 if (!bfd_link_pic (info
))
4181 /* If not PIC, add the .got.plt section address for
4182 baseless addressing. */
4184 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4185 if ((modrm
& 0xc7) == 0x5)
4186 relocation
+= offplt
;
4189 unresolved_reloc
= FALSE
;
4194 /* Relocation is to the entry for this symbol in the global
4196 if (htab
->elf
.sgot
== NULL
)
4203 off
= h
->got
.offset
;
4204 dyn
= htab
->elf
.dynamic_sections_created
;
4205 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4206 bfd_link_pic (info
),
4208 || (bfd_link_pic (info
)
4209 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4210 || (ELF_ST_VISIBILITY (h
->other
)
4211 && h
->root
.type
== bfd_link_hash_undefweak
))
4213 /* This is actually a static link, or it is a
4214 -Bsymbolic link and the symbol is defined
4215 locally, or the symbol was forced to be local
4216 because of a version file. We must initialize
4217 this entry in the global offset table. Since the
4218 offset must always be a multiple of 4, we use the
4219 least significant bit to record whether we have
4220 initialized it already.
4222 When doing a dynamic link, we create a .rel.got
4223 relocation entry to initialize the value. This
4224 is done in the finish_dynamic_symbol routine. */
4229 bfd_put_32 (output_bfd
, relocation
,
4230 htab
->elf
.sgot
->contents
+ off
);
4235 unresolved_reloc
= FALSE
;
4239 if (local_got_offsets
== NULL
)
4242 off
= local_got_offsets
[r_symndx
];
4244 /* The offset must always be a multiple of 4. We use
4245 the least significant bit to record whether we have
4246 already generated the necessary reloc. */
4251 bfd_put_32 (output_bfd
, relocation
,
4252 htab
->elf
.sgot
->contents
+ off
);
4254 if (bfd_link_pic (info
))
4257 Elf_Internal_Rela outrel
;
4259 s
= htab
->elf
.srelgot
;
4263 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4264 + htab
->elf
.sgot
->output_offset
4266 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4267 elf_append_rel (output_bfd
, s
, &outrel
);
4270 local_got_offsets
[r_symndx
] |= 1;
4274 if (off
>= (bfd_vma
) -2)
4277 relocation
= (htab
->elf
.sgot
->output_section
->vma
4278 + htab
->elf
.sgot
->output_offset
+ off
);
4279 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4281 if (bfd_link_pic (info
))
4283 /* For PIC, disallow R_386_GOT32 without a base
4284 register since we don't know what the GOT base
4290 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4293 name
= h
->root
.root
.string
;
4296 (_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
4297 input_bfd
, howto
->name
, name
);
4298 bfd_set_error (bfd_error_bad_value
);
4304 /* Subtract the .got.plt section address only with a base
4306 relocation
-= (htab
->elf
.sgotplt
->output_section
->vma
4307 + htab
->elf
.sgotplt
->output_offset
);
4313 /* Relocation is relative to the start of the global offset
4316 /* Check to make sure it isn't a protected function or data
4317 symbol for shared library since it may not be local when
4318 used as function address or with copy relocation. We also
4319 need to make sure that a symbol is referenced locally. */
4320 if (!bfd_link_executable (info
) && h
)
4322 if (!h
->def_regular
)
4326 switch (ELF_ST_VISIBILITY (h
->other
))
4329 v
= _("hidden symbol");
4332 v
= _("internal symbol");
4335 v
= _("protected symbol");
4343 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4344 input_bfd
, v
, h
->root
.root
.string
);
4345 bfd_set_error (bfd_error_bad_value
);
4348 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4349 && (h
->type
== STT_FUNC
4350 || h
->type
== STT_OBJECT
)
4351 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4354 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4356 h
->type
== STT_FUNC
? "function" : "data",
4357 h
->root
.root
.string
);
4358 bfd_set_error (bfd_error_bad_value
);
4363 /* Note that sgot is not involved in this
4364 calculation. We always want the start of .got.plt. If we
4365 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4366 permitted by the ABI, we might have to change this
4368 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4369 + htab
->elf
.sgotplt
->output_offset
;
4373 /* Use global offset table as symbol value. */
4374 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4375 + htab
->elf
.sgotplt
->output_offset
;
4376 unresolved_reloc
= FALSE
;
4380 /* Relocation is to the entry for this symbol in the
4381 procedure linkage table. */
4383 /* Resolve a PLT32 reloc against a local symbol directly,
4384 without using the procedure linkage table. */
4388 if ((h
->plt
.offset
== (bfd_vma
) -1
4389 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4390 || htab
->elf
.splt
== NULL
)
4392 /* We didn't make a PLT entry for this symbol. This
4393 happens when statically linking PIC code, or when
4394 using -Bsymbolic. */
4398 if (h
->plt
.offset
!= (bfd_vma
) -1)
4400 resolved_plt
= htab
->elf
.splt
;
4401 plt_offset
= h
->plt
.offset
;
4405 resolved_plt
= htab
->plt_got
;
4406 plt_offset
= eh
->plt_got
.offset
;
4409 relocation
= (resolved_plt
->output_section
->vma
4410 + resolved_plt
->output_offset
4412 unresolved_reloc
= FALSE
;
4416 /* Set to symbol size. */
4417 relocation
= st_size
;
4422 if ((input_section
->flags
& SEC_ALLOC
) == 0
4426 /* Copy dynamic function pointer relocations. Don't generate
4427 dynamic relocations against resolved undefined weak symbols
4428 in PIE, except for R_386_PC32. */
4429 if ((bfd_link_pic (info
)
4431 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4432 && (!resolved_to_zero
4433 || r_type
== R_386_PC32
))
4434 || h
->root
.type
!= bfd_link_hash_undefweak
))
4435 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4436 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4437 || (ELIMINATE_COPY_RELOCS
4438 && !bfd_link_pic (info
)
4442 || eh
->func_pointer_refcount
> 0
4443 || (h
->root
.type
== bfd_link_hash_undefweak
4444 && !resolved_to_zero
))
4445 && ((h
->def_dynamic
&& !h
->def_regular
)
4446 /* Undefined weak symbol is bound locally when
4448 || h
->root
.type
== bfd_link_hash_undefweak
)))
4450 Elf_Internal_Rela outrel
;
4451 bfd_boolean skip
, relocate
;
4454 /* When generating a shared object, these relocations
4455 are copied into the output file to be resolved at run
4462 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4464 if (outrel
.r_offset
== (bfd_vma
) -1)
4466 else if (outrel
.r_offset
== (bfd_vma
) -2)
4467 skip
= TRUE
, relocate
= TRUE
;
4468 outrel
.r_offset
+= (input_section
->output_section
->vma
4469 + input_section
->output_offset
);
4472 memset (&outrel
, 0, sizeof outrel
);
4475 && (r_type
== R_386_PC32
4476 || !(bfd_link_executable (info
)
4477 || SYMBOLIC_BIND (info
, h
))
4478 || !h
->def_regular
))
4479 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4482 /* This symbol is local, or marked to become local. */
4484 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4487 sreloc
= elf_section_data (input_section
)->sreloc
;
4489 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4491 r
= bfd_reloc_notsupported
;
4492 goto check_relocation_error
;
4495 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4497 /* If this reloc is against an external symbol, we do
4498 not want to fiddle with the addend. Otherwise, we
4499 need to include the symbol value so that it becomes
4500 an addend for the dynamic reloc. */
4507 if (!bfd_link_executable (info
))
4509 Elf_Internal_Rela outrel
;
4512 outrel
.r_offset
= rel
->r_offset
4513 + input_section
->output_section
->vma
4514 + input_section
->output_offset
;
4515 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4516 sreloc
= elf_section_data (input_section
)->sreloc
;
4519 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4524 case R_386_TLS_GOTDESC
:
4525 case R_386_TLS_DESC_CALL
:
4526 case R_386_TLS_IE_32
:
4527 case R_386_TLS_GOTIE
:
4528 tls_type
= GOT_UNKNOWN
;
4529 if (h
== NULL
&& local_got_offsets
)
4530 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4532 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4533 if (tls_type
== GOT_TLS_IE
)
4534 tls_type
= GOT_TLS_IE_NEG
;
4536 if (! elf_i386_tls_transition (info
, input_bfd
,
4537 input_section
, contents
,
4538 symtab_hdr
, sym_hashes
,
4539 &r_type
, tls_type
, rel
,
4540 relend
, h
, r_symndx
, TRUE
))
4543 if (r_type
== R_386_TLS_LE_32
)
4545 BFD_ASSERT (! unresolved_reloc
);
4546 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4551 /* GD->LE transition. */
4552 type
= *(contents
+ rel
->r_offset
- 2);
4556 leal foo@tlsgd(,%ebx,1), %eax
4557 call ___tls_get_addr@PLT
4560 subl $foo@tpoff, %eax
4561 (6 byte form of subl). */
4562 roff
= rel
->r_offset
+ 5;
4567 leal foo@tlsgd(%ebx), %eax
4568 call ___tls_get_addr@PLT
4571 leal foo@tlsgd(%reg), %eax
4572 call *___tls_get_addr@GOT(%reg)
4573 which may be converted to
4574 addr32 call ___tls_get_addr
4576 movl %gs:0, %eax; subl $foo@tpoff, %eax
4577 (6 byte form of subl). */
4578 roff
= rel
->r_offset
+ 6;
4580 memcpy (contents
+ roff
- 8,
4581 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4582 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4584 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4589 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4591 /* GDesc -> LE transition.
4592 It's originally something like:
4593 leal x@tlsdesc(%ebx), %eax
4597 Registers other than %eax may be set up here. */
4602 roff
= rel
->r_offset
;
4603 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4605 /* Now modify the instruction as appropriate. */
4606 /* aoliva FIXME: remove the above and xor the byte
4608 bfd_put_8 (output_bfd
, val
^ 0x86,
4609 contents
+ roff
- 1);
4610 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4614 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4616 /* GDesc -> LE transition.
4624 roff
= rel
->r_offset
;
4625 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4626 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4629 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4633 /* IE->LE transition:
4634 Originally it can be one of:
4642 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4645 /* movl foo, %eax. */
4646 bfd_put_8 (output_bfd
, 0xb8,
4647 contents
+ rel
->r_offset
- 1);
4653 type
= bfd_get_8 (input_bfd
,
4654 contents
+ rel
->r_offset
- 2);
4659 bfd_put_8 (output_bfd
, 0xc7,
4660 contents
+ rel
->r_offset
- 2);
4661 bfd_put_8 (output_bfd
,
4662 0xc0 | ((val
>> 3) & 7),
4663 contents
+ rel
->r_offset
- 1);
4667 bfd_put_8 (output_bfd
, 0x81,
4668 contents
+ rel
->r_offset
- 2);
4669 bfd_put_8 (output_bfd
,
4670 0xc0 | ((val
>> 3) & 7),
4671 contents
+ rel
->r_offset
- 1);
4678 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4679 contents
+ rel
->r_offset
);
4684 unsigned int val
, type
;
4686 /* {IE_32,GOTIE}->LE transition:
4687 Originally it can be one of:
4688 subl foo(%reg1), %reg2
4689 movl foo(%reg1), %reg2
4690 addl foo(%reg1), %reg2
4693 movl $foo, %reg2 (6 byte form)
4694 addl $foo, %reg2. */
4695 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4696 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4700 bfd_put_8 (output_bfd
, 0xc7,
4701 contents
+ rel
->r_offset
- 2);
4702 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4703 contents
+ rel
->r_offset
- 1);
4705 else if (type
== 0x2b)
4708 bfd_put_8 (output_bfd
, 0x81,
4709 contents
+ rel
->r_offset
- 2);
4710 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4711 contents
+ rel
->r_offset
- 1);
4713 else if (type
== 0x03)
4716 bfd_put_8 (output_bfd
, 0x81,
4717 contents
+ rel
->r_offset
- 2);
4718 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4719 contents
+ rel
->r_offset
- 1);
4723 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4724 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4725 contents
+ rel
->r_offset
);
4727 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4728 contents
+ rel
->r_offset
);
4733 if (htab
->elf
.sgot
== NULL
)
4738 off
= h
->got
.offset
;
4739 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4743 if (local_got_offsets
== NULL
)
4746 off
= local_got_offsets
[r_symndx
];
4747 offplt
= local_tlsdesc_gotents
[r_symndx
];
4754 Elf_Internal_Rela outrel
;
4758 if (htab
->elf
.srelgot
== NULL
)
4761 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4763 if (GOT_TLS_GDESC_P (tls_type
))
4766 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4767 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4768 <= htab
->elf
.sgotplt
->size
);
4769 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4770 + htab
->elf
.sgotplt
->output_offset
4772 + htab
->sgotplt_jump_table_size
);
4773 sreloc
= htab
->elf
.srelplt
;
4774 loc
= sreloc
->contents
;
4775 loc
+= (htab
->next_tls_desc_index
++
4776 * sizeof (Elf32_External_Rel
));
4777 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4778 <= sreloc
->contents
+ sreloc
->size
);
4779 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4782 BFD_ASSERT (! unresolved_reloc
);
4783 bfd_put_32 (output_bfd
,
4784 relocation
- elf_i386_dtpoff_base (info
),
4785 htab
->elf
.sgotplt
->contents
+ offplt
4786 + htab
->sgotplt_jump_table_size
+ 4);
4790 bfd_put_32 (output_bfd
, 0,
4791 htab
->elf
.sgotplt
->contents
+ offplt
4792 + htab
->sgotplt_jump_table_size
+ 4);
4796 sreloc
= htab
->elf
.srelgot
;
4798 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4799 + htab
->elf
.sgot
->output_offset
+ off
);
4801 if (GOT_TLS_GD_P (tls_type
))
4802 dr_type
= R_386_TLS_DTPMOD32
;
4803 else if (GOT_TLS_GDESC_P (tls_type
))
4805 else if (tls_type
== GOT_TLS_IE_POS
)
4806 dr_type
= R_386_TLS_TPOFF
;
4808 dr_type
= R_386_TLS_TPOFF32
;
4810 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4811 bfd_put_32 (output_bfd
,
4812 relocation
- elf_i386_dtpoff_base (info
),
4813 htab
->elf
.sgot
->contents
+ off
);
4814 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4815 bfd_put_32 (output_bfd
,
4816 elf_i386_dtpoff_base (info
) - relocation
,
4817 htab
->elf
.sgot
->contents
+ off
);
4818 else if (dr_type
!= R_386_TLS_DESC
)
4819 bfd_put_32 (output_bfd
, 0,
4820 htab
->elf
.sgot
->contents
+ off
);
4821 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4823 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4825 if (GOT_TLS_GD_P (tls_type
))
4829 BFD_ASSERT (! unresolved_reloc
);
4830 bfd_put_32 (output_bfd
,
4831 relocation
- elf_i386_dtpoff_base (info
),
4832 htab
->elf
.sgot
->contents
+ off
+ 4);
4836 bfd_put_32 (output_bfd
, 0,
4837 htab
->elf
.sgot
->contents
+ off
+ 4);
4838 outrel
.r_info
= ELF32_R_INFO (indx
,
4839 R_386_TLS_DTPOFF32
);
4840 outrel
.r_offset
+= 4;
4841 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4844 else if (tls_type
== GOT_TLS_IE_BOTH
)
4846 bfd_put_32 (output_bfd
,
4848 ? relocation
- elf_i386_dtpoff_base (info
)
4850 htab
->elf
.sgot
->contents
+ off
+ 4);
4851 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4852 outrel
.r_offset
+= 4;
4853 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4860 local_got_offsets
[r_symndx
] |= 1;
4863 if (off
>= (bfd_vma
) -2
4864 && ! GOT_TLS_GDESC_P (tls_type
))
4866 if (r_type
== R_386_TLS_GOTDESC
4867 || r_type
== R_386_TLS_DESC_CALL
)
4869 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4870 unresolved_reloc
= FALSE
;
4872 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4874 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4875 + htab
->elf
.sgotplt
->output_offset
;
4876 relocation
= htab
->elf
.sgot
->output_section
->vma
4877 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4878 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4879 && tls_type
== GOT_TLS_IE_BOTH
)
4881 if (r_type
== R_386_TLS_IE
)
4882 relocation
+= g_o_t
;
4883 unresolved_reloc
= FALSE
;
4885 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4887 unsigned int val
, type
;
4890 /* GD->IE transition. */
4891 type
= *(contents
+ rel
->r_offset
- 2);
4892 val
= *(contents
+ rel
->r_offset
- 1);
4896 leal foo@tlsgd(,%ebx,1), %eax
4897 call ___tls_get_addr@PLT
4900 subl $foo@gottpoff(%ebx), %eax. */
4902 roff
= rel
->r_offset
- 3;
4907 leal foo@tlsgd(%ebx), %eax
4908 call ___tls_get_addr@PLT
4911 leal foo@tlsgd(%reg), %eax
4912 call *___tls_get_addr@GOT(%reg)
4913 which may be converted to
4914 addr32 call ___tls_get_addr
4917 subl $foo@gottpoff(%reg), %eax. */
4918 roff
= rel
->r_offset
- 2;
4920 memcpy (contents
+ roff
,
4921 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4922 contents
[roff
+ 7] = 0x80 | (val
& 7);
4923 /* If foo is used only with foo@gotntpoff(%reg) and
4924 foo@indntpoff, but not with foo@gottpoff(%reg), change
4925 subl $foo@gottpoff(%reg), %eax
4927 addl $foo@gotntpoff(%reg), %eax. */
4928 if (tls_type
== GOT_TLS_IE_POS
)
4929 contents
[roff
+ 6] = 0x03;
4930 bfd_put_32 (output_bfd
,
4931 htab
->elf
.sgot
->output_section
->vma
4932 + htab
->elf
.sgot
->output_offset
+ off
4933 - htab
->elf
.sgotplt
->output_section
->vma
4934 - htab
->elf
.sgotplt
->output_offset
,
4935 contents
+ roff
+ 8);
4936 /* Skip R_386_PLT32 and R_386_GOT32X. */
4941 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4943 /* GDesc -> IE transition.
4944 It's originally something like:
4945 leal x@tlsdesc(%ebx), %eax
4948 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4950 movl x@gottpoff(%ebx), %eax # before negl %eax
4952 Registers other than %eax may be set up here. */
4956 /* First, make sure it's a leal adding ebx to a 32-bit
4957 offset into any register, although it's probably
4958 almost always going to be eax. */
4959 roff
= rel
->r_offset
;
4961 /* Now modify the instruction as appropriate. */
4962 /* To turn a leal into a movl in the form we use it, it
4963 suffices to change the first byte from 0x8d to 0x8b.
4964 aoliva FIXME: should we decide to keep the leal, all
4965 we have to do is remove the statement below, and
4966 adjust the relaxation of R_386_TLS_DESC_CALL. */
4967 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4969 if (tls_type
== GOT_TLS_IE_BOTH
)
4972 bfd_put_32 (output_bfd
,
4973 htab
->elf
.sgot
->output_section
->vma
4974 + htab
->elf
.sgot
->output_offset
+ off
4975 - htab
->elf
.sgotplt
->output_section
->vma
4976 - htab
->elf
.sgotplt
->output_offset
,
4980 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4982 /* GDesc -> IE transition.
4990 depending on how we transformed the TLS_GOTDESC above.
4995 roff
= rel
->r_offset
;
4997 /* Now modify the instruction as appropriate. */
4998 if (tls_type
!= GOT_TLS_IE_NEG
)
5001 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5002 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5007 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
5008 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
5018 if (! elf_i386_tls_transition (info
, input_bfd
,
5019 input_section
, contents
,
5020 symtab_hdr
, sym_hashes
,
5021 &r_type
, GOT_UNKNOWN
, rel
,
5022 relend
, h
, r_symndx
, TRUE
))
5025 if (r_type
!= R_386_TLS_LDM
)
5027 /* LD->LE transition. Change
5028 leal foo@tlsldm(%ebx) %eax
5029 call ___tls_get_addr@PLT
5033 leal 0(%esi,1), %esi
5035 leal foo@tlsldm(%reg) %eax
5036 call *___tls_get_addr@GOT(%reg)
5037 which may be converted to
5038 addr32 call ___tls_get_addr
5041 leal 0(%esi), %esi */
5042 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
5043 if (*(contents
+ rel
->r_offset
+ 4) == 0xff
5044 || *(contents
+ rel
->r_offset
+ 4) == 0x67)
5045 memcpy (contents
+ rel
->r_offset
- 2,
5046 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5048 memcpy (contents
+ rel
->r_offset
- 2,
5049 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5050 /* Skip R_386_PC32/R_386_PLT32. */
5056 if (htab
->elf
.sgot
== NULL
)
5059 off
= htab
->tls_ldm_got
.offset
;
5064 Elf_Internal_Rela outrel
;
5066 if (htab
->elf
.srelgot
== NULL
)
5069 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5070 + htab
->elf
.sgot
->output_offset
+ off
);
5072 bfd_put_32 (output_bfd
, 0,
5073 htab
->elf
.sgot
->contents
+ off
);
5074 bfd_put_32 (output_bfd
, 0,
5075 htab
->elf
.sgot
->contents
+ off
+ 4);
5076 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
5077 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
5078 htab
->tls_ldm_got
.offset
|= 1;
5080 relocation
= htab
->elf
.sgot
->output_section
->vma
5081 + htab
->elf
.sgot
->output_offset
+ off
5082 - htab
->elf
.sgotplt
->output_section
->vma
5083 - htab
->elf
.sgotplt
->output_offset
;
5084 unresolved_reloc
= FALSE
;
5087 case R_386_TLS_LDO_32
:
5088 if (!bfd_link_executable (info
)
5089 || (input_section
->flags
& SEC_CODE
) == 0)
5090 relocation
-= elf_i386_dtpoff_base (info
);
5092 /* When converting LDO to LE, we must negate. */
5093 relocation
= -elf_i386_tpoff (info
, relocation
);
5096 case R_386_TLS_LE_32
:
5098 if (!bfd_link_executable (info
))
5100 Elf_Internal_Rela outrel
;
5103 outrel
.r_offset
= rel
->r_offset
5104 + input_section
->output_section
->vma
5105 + input_section
->output_offset
;
5106 if (h
!= NULL
&& h
->dynindx
!= -1)
5110 if (r_type
== R_386_TLS_LE_32
)
5111 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
5113 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
5114 sreloc
= elf_section_data (input_section
)->sreloc
;
5117 elf_append_rel (output_bfd
, sreloc
, &outrel
);
5120 else if (r_type
== R_386_TLS_LE_32
)
5121 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
5123 relocation
-= elf_i386_dtpoff_base (info
);
5125 else if (r_type
== R_386_TLS_LE_32
)
5126 relocation
= elf_i386_tpoff (info
, relocation
);
5128 relocation
= -elf_i386_tpoff (info
, relocation
);
5135 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5136 because such sections are not SEC_ALLOC and thus ld.so will
5137 not process them. */
5138 if (unresolved_reloc
5139 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5141 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5142 rel
->r_offset
) != (bfd_vma
) -1)
5145 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5148 (long) rel
->r_offset
,
5150 h
->root
.root
.string
);
5155 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5156 contents
, rel
->r_offset
,
5159 check_relocation_error
:
5160 if (r
!= bfd_reloc_ok
)
5165 name
= h
->root
.root
.string
;
5168 name
= bfd_elf_string_from_elf_section (input_bfd
,
5169 symtab_hdr
->sh_link
,
5174 name
= bfd_section_name (input_bfd
, sec
);
5177 if (r
== bfd_reloc_overflow
)
5178 (*info
->callbacks
->reloc_overflow
)
5179 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5180 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5184 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5185 input_bfd
, input_section
,
5186 (long) rel
->r_offset
, name
, (int) r
);
5197 Elf_Internal_Shdr
*rel_hdr
;
5198 size_t deleted
= rel
- wrel
;
5200 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5201 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5202 if (rel_hdr
->sh_size
== 0)
5204 /* It is too late to remove an empty reloc section. Leave
5206 ??? What is wrong with an empty section??? */
5207 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5210 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5211 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5212 input_section
->reloc_count
-= deleted
;
5218 /* Finish up dynamic symbol handling. We set the contents of various
5219 dynamic sections here. */
5222 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5223 struct bfd_link_info
*info
,
5224 struct elf_link_hash_entry
*h
,
5225 Elf_Internal_Sym
*sym
)
5227 struct elf_i386_link_hash_table
*htab
;
5228 unsigned plt_entry_size
;
5229 const struct elf_i386_backend_data
*abed
;
5230 struct elf_i386_link_hash_entry
*eh
;
5231 bfd_boolean local_undefweak
;
5233 htab
= elf_i386_hash_table (info
);
5237 abed
= get_elf_i386_backend_data (output_bfd
);
5238 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5240 eh
= (struct elf_i386_link_hash_entry
*) h
;
5242 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5243 resolved undefined weak symbols in executable so that their
5244 references have value 0 at run-time. */
5245 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5249 if (h
->plt
.offset
!= (bfd_vma
) -1)
5253 Elf_Internal_Rela rel
;
5255 asection
*plt
, *gotplt
, *relplt
;
5257 /* When building a static executable, use .iplt, .igot.plt and
5258 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5259 if (htab
->elf
.splt
!= NULL
)
5261 plt
= htab
->elf
.splt
;
5262 gotplt
= htab
->elf
.sgotplt
;
5263 relplt
= htab
->elf
.srelplt
;
5267 plt
= htab
->elf
.iplt
;
5268 gotplt
= htab
->elf
.igotplt
;
5269 relplt
= htab
->elf
.irelplt
;
5272 /* This symbol has an entry in the procedure linkage table. Set
5275 if ((h
->dynindx
== -1
5277 && !((h
->forced_local
|| bfd_link_executable (info
))
5279 && h
->type
== STT_GNU_IFUNC
))
5285 /* Get the index in the procedure linkage table which
5286 corresponds to this symbol. This is the index of this symbol
5287 in all the symbols for which we are making plt entries. The
5288 first entry in the procedure linkage table is reserved.
5290 Get the offset into the .got table of the entry that
5291 corresponds to this function. Each .got entry is 4 bytes.
5292 The first three are reserved.
5294 For static executables, we don't reserve anything. */
5296 if (plt
== htab
->elf
.splt
)
5298 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5299 got_offset
= (got_offset
+ 3) * 4;
5303 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5304 got_offset
= got_offset
* 4;
5307 /* Fill in the entry in the procedure linkage table. */
5308 if (! bfd_link_pic (info
))
5310 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5311 abed
->plt
->plt_entry_size
);
5312 bfd_put_32 (output_bfd
,
5313 (gotplt
->output_section
->vma
5314 + gotplt
->output_offset
5316 plt
->contents
+ h
->plt
.offset
5317 + abed
->plt
->plt_got_offset
);
5319 if (abed
->is_vxworks
)
5321 int s
, k
, reloc_index
;
5323 /* Create the R_386_32 relocation referencing the GOT
5324 for this PLT entry. */
5326 /* S: Current slot number (zero-based). */
5327 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5328 / abed
->plt
->plt_entry_size
);
5329 /* K: Number of relocations for PLTResolve. */
5330 if (bfd_link_pic (info
))
5331 k
= PLTRESOLVE_RELOCS_SHLIB
;
5333 k
= PLTRESOLVE_RELOCS
;
5334 /* Skip the PLTresolve relocations, and the relocations for
5335 the other PLT slots. */
5336 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5337 loc
= (htab
->srelplt2
->contents
+ reloc_index
5338 * sizeof (Elf32_External_Rel
));
5340 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5341 + htab
->elf
.splt
->output_offset
5342 + h
->plt
.offset
+ 2),
5343 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5344 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5346 /* Create the R_386_32 relocation referencing the beginning of
5347 the PLT for this GOT entry. */
5348 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5349 + htab
->elf
.sgotplt
->output_offset
5351 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5352 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5353 loc
+ sizeof (Elf32_External_Rel
));
5358 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5359 abed
->plt
->plt_entry_size
);
5360 bfd_put_32 (output_bfd
, got_offset
,
5361 plt
->contents
+ h
->plt
.offset
5362 + abed
->plt
->plt_got_offset
);
5365 /* Fill in the entry in the global offset table. Leave the entry
5366 as zero for undefined weak symbol in PIE. No PLT relocation
5367 against undefined weak symbol in PIE. */
5368 if (!local_undefweak
)
5370 bfd_put_32 (output_bfd
,
5371 (plt
->output_section
->vma
5372 + plt
->output_offset
5374 + abed
->plt
->plt_lazy_offset
),
5375 gotplt
->contents
+ got_offset
);
5377 /* Fill in the entry in the .rel.plt section. */
5378 rel
.r_offset
= (gotplt
->output_section
->vma
5379 + gotplt
->output_offset
5381 if (h
->dynindx
== -1
5382 || ((bfd_link_executable (info
)
5383 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5385 && h
->type
== STT_GNU_IFUNC
))
5387 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5388 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5389 in the .got.plt section. */
5390 bfd_put_32 (output_bfd
,
5391 (h
->root
.u
.def
.value
5392 + h
->root
.u
.def
.section
->output_section
->vma
5393 + h
->root
.u
.def
.section
->output_offset
),
5394 gotplt
->contents
+ got_offset
);
5395 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5396 /* R_386_IRELATIVE comes last. */
5397 plt_index
= htab
->next_irelative_index
--;
5401 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5402 plt_index
= htab
->next_jump_slot_index
++;
5405 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5406 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5408 /* Don't fill PLT entry for static executables. */
5409 if (plt
== htab
->elf
.splt
)
5411 bfd_put_32 (output_bfd
,
5412 plt_index
* sizeof (Elf32_External_Rel
),
5413 plt
->contents
+ h
->plt
.offset
5414 + abed
->plt
->plt_reloc_offset
);
5415 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5416 + abed
->plt
->plt_plt_offset
+ 4),
5417 plt
->contents
+ h
->plt
.offset
5418 + abed
->plt
->plt_plt_offset
);
5422 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5424 bfd_vma got_offset
, plt_offset
;
5425 asection
*plt
, *got
, *gotplt
;
5426 const bfd_byte
*got_plt_entry
;
5428 /* Offset of displacement of the indirect jump. */
5429 bfd_vma plt_got_offset
= 2;
5431 /* Set the entry in the GOT procedure linkage table. */
5432 plt
= htab
->plt_got
;
5433 got
= htab
->elf
.sgot
;
5434 gotplt
= htab
->elf
.sgotplt
;
5435 got_offset
= h
->got
.offset
;
5437 if (got_offset
== (bfd_vma
) -1
5443 /* Fill in the entry in the GOT procedure linkage table. */
5444 if (! bfd_link_pic (info
))
5446 got_plt_entry
= elf_i386_got_plt_entry
;
5447 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5451 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5452 got_offset
+= (got
->output_section
->vma
5453 + got
->output_offset
5454 - gotplt
->output_section
->vma
5455 - gotplt
->output_offset
);
5458 plt_offset
= eh
->plt_got
.offset
;
5459 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5460 sizeof (elf_i386_got_plt_entry
));
5461 bfd_put_32 (output_bfd
, got_offset
,
5462 plt
->contents
+ plt_offset
+ plt_got_offset
);
5465 if (!local_undefweak
5467 && (h
->plt
.offset
!= (bfd_vma
) -1
5468 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5470 /* Mark the symbol as undefined, rather than as defined in
5471 the .plt section. Leave the value if there were any
5472 relocations where pointer equality matters (this is a clue
5473 for the dynamic linker, to make function pointer
5474 comparisons work between an application and shared
5475 library), otherwise set it to zero. If a function is only
5476 called from a binary, there is no need to slow down
5477 shared libraries because of that. */
5478 sym
->st_shndx
= SHN_UNDEF
;
5479 if (!h
->pointer_equality_needed
)
5483 /* Don't generate dynamic GOT relocation against undefined weak
5484 symbol in executable. */
5485 if (h
->got
.offset
!= (bfd_vma
) -1
5486 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5487 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5488 && !local_undefweak
)
5490 Elf_Internal_Rela rel
;
5491 asection
*relgot
= htab
->elf
.srelgot
;
5493 /* This symbol has an entry in the global offset table. Set it
5496 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5499 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5500 + htab
->elf
.sgot
->output_offset
5501 + (h
->got
.offset
& ~(bfd_vma
) 1));
5503 /* If this is a static link, or it is a -Bsymbolic link and the
5504 symbol is defined locally or was forced to be local because
5505 of a version file, we just want to emit a RELATIVE reloc.
5506 The entry in the global offset table will already have been
5507 initialized in the relocate_section function. */
5509 && h
->type
== STT_GNU_IFUNC
)
5511 if (h
->plt
.offset
== (bfd_vma
) -1)
5513 /* STT_GNU_IFUNC is referenced without PLT. */
5514 if (htab
->elf
.splt
== NULL
)
5516 /* use .rel[a].iplt section to store .got relocations
5517 in static executable. */
5518 relgot
= htab
->elf
.irelplt
;
5520 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5522 bfd_put_32 (output_bfd
,
5523 (h
->root
.u
.def
.value
5524 + h
->root
.u
.def
.section
->output_section
->vma
5525 + h
->root
.u
.def
.section
->output_offset
),
5526 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5527 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5532 else if (bfd_link_pic (info
))
5534 /* Generate R_386_GLOB_DAT. */
5541 if (!h
->pointer_equality_needed
)
5544 /* For non-shared object, we can't use .got.plt, which
5545 contains the real function addres if we need pointer
5546 equality. We load the GOT entry with the PLT entry. */
5547 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5548 bfd_put_32 (output_bfd
,
5549 (plt
->output_section
->vma
5550 + plt
->output_offset
+ h
->plt
.offset
),
5551 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5555 else if (bfd_link_pic (info
)
5556 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5558 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5559 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5563 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5565 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5566 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5567 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5570 elf_append_rel (output_bfd
, relgot
, &rel
);
5575 Elf_Internal_Rela rel
;
5577 /* This symbol needs a copy reloc. Set it up. */
5579 if (h
->dynindx
== -1
5580 || (h
->root
.type
!= bfd_link_hash_defined
5581 && h
->root
.type
!= bfd_link_hash_defweak
)
5582 || htab
->srelbss
== NULL
)
5585 rel
.r_offset
= (h
->root
.u
.def
.value
5586 + h
->root
.u
.def
.section
->output_section
->vma
5587 + h
->root
.u
.def
.section
->output_offset
);
5588 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5589 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5595 /* Finish up local dynamic symbol handling. We set the contents of
5596 various dynamic sections here. */
5599 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5601 struct elf_link_hash_entry
*h
5602 = (struct elf_link_hash_entry
*) *slot
;
5603 struct bfd_link_info
*info
5604 = (struct bfd_link_info
*) inf
;
5606 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5610 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5611 here since undefined weak symbol may not be dynamic and may not be
5612 called for elf_i386_finish_dynamic_symbol. */
5615 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5618 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5619 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5621 if (h
->root
.type
!= bfd_link_hash_undefweak
5622 || h
->dynindx
!= -1)
5625 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5629 /* Used to decide how to sort relocs in an optimal manner for the
5630 dynamic linker, before writing them out. */
5632 static enum elf_reloc_type_class
5633 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5634 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5635 const Elf_Internal_Rela
*rela
)
5637 bfd
*abfd
= info
->output_bfd
;
5638 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5639 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5641 if (htab
->dynsym
!= NULL
5642 && htab
->dynsym
->contents
!= NULL
)
5644 /* Check relocation against STT_GNU_IFUNC symbol if there are
5646 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5647 if (r_symndx
!= STN_UNDEF
)
5649 Elf_Internal_Sym sym
;
5650 if (!bed
->s
->swap_symbol_in (abfd
,
5651 (htab
->dynsym
->contents
5652 + r_symndx
* sizeof (Elf32_External_Sym
)),
5656 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5657 return reloc_class_ifunc
;
5661 switch (ELF32_R_TYPE (rela
->r_info
))
5663 case R_386_IRELATIVE
:
5664 return reloc_class_ifunc
;
5665 case R_386_RELATIVE
:
5666 return reloc_class_relative
;
5667 case R_386_JUMP_SLOT
:
5668 return reloc_class_plt
;
5670 return reloc_class_copy
;
5672 return reloc_class_normal
;
5676 /* Finish up the dynamic sections. */
5679 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5680 struct bfd_link_info
*info
)
5682 struct elf_i386_link_hash_table
*htab
;
5685 const struct elf_i386_backend_data
*abed
;
5687 htab
= elf_i386_hash_table (info
);
5691 dynobj
= htab
->elf
.dynobj
;
5692 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5693 abed
= get_elf_i386_backend_data (output_bfd
);
5695 if (htab
->elf
.dynamic_sections_created
)
5697 Elf32_External_Dyn
*dyncon
, *dynconend
;
5699 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5702 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5703 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5704 for (; dyncon
< dynconend
; dyncon
++)
5706 Elf_Internal_Dyn dyn
;
5709 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5714 if (abed
->is_vxworks
5715 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5720 s
= htab
->elf
.sgotplt
;
5721 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5725 s
= htab
->elf
.srelplt
;
5726 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5730 s
= htab
->elf
.srelplt
;
5731 dyn
.d_un
.d_val
= s
->size
;
5735 /* My reading of the SVR4 ABI indicates that the
5736 procedure linkage table relocs (DT_JMPREL) should be
5737 included in the overall relocs (DT_REL). This is
5738 what Solaris does. However, UnixWare can not handle
5739 that case. Therefore, we override the DT_RELSZ entry
5740 here to make it not include the JMPREL relocs. */
5741 s
= htab
->elf
.srelplt
;
5744 dyn
.d_un
.d_val
-= s
->size
;
5748 /* We may not be using the standard ELF linker script.
5749 If .rel.plt is the first .rel section, we adjust
5750 DT_REL to not include it. */
5751 s
= htab
->elf
.srelplt
;
5754 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5756 dyn
.d_un
.d_ptr
+= s
->size
;
5760 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5763 /* Fill in the first entry in the procedure linkage table. */
5764 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5766 if (bfd_link_pic (info
))
5768 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5769 abed
->plt
->plt0_entry_size
);
5770 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5771 abed
->plt0_pad_byte
,
5772 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5776 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5777 abed
->plt
->plt0_entry_size
);
5778 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5779 abed
->plt0_pad_byte
,
5780 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5781 bfd_put_32 (output_bfd
,
5782 (htab
->elf
.sgotplt
->output_section
->vma
5783 + htab
->elf
.sgotplt
->output_offset
5785 htab
->elf
.splt
->contents
5786 + abed
->plt
->plt0_got1_offset
);
5787 bfd_put_32 (output_bfd
,
5788 (htab
->elf
.sgotplt
->output_section
->vma
5789 + htab
->elf
.sgotplt
->output_offset
5791 htab
->elf
.splt
->contents
5792 + abed
->plt
->plt0_got2_offset
);
5794 if (abed
->is_vxworks
)
5796 Elf_Internal_Rela rel
;
5798 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5799 On IA32 we use REL relocations so the addend goes in
5800 the PLT directly. */
5801 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5802 + htab
->elf
.splt
->output_offset
5803 + abed
->plt
->plt0_got1_offset
);
5804 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5805 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5806 htab
->srelplt2
->contents
);
5807 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5808 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5809 + htab
->elf
.splt
->output_offset
5810 + abed
->plt
->plt0_got2_offset
);
5811 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5812 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5813 htab
->srelplt2
->contents
+
5814 sizeof (Elf32_External_Rel
));
5818 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5819 really seem like the right value. */
5820 elf_section_data (htab
->elf
.splt
->output_section
)
5821 ->this_hdr
.sh_entsize
= 4;
5823 /* Correct the .rel.plt.unloaded relocations. */
5824 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5826 int num_plts
= (htab
->elf
.splt
->size
5827 / abed
->plt
->plt_entry_size
) - 1;
5830 p
= htab
->srelplt2
->contents
;
5831 if (bfd_link_pic (info
))
5832 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5834 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5836 for (; num_plts
; num_plts
--)
5838 Elf_Internal_Rela rel
;
5839 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5840 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5841 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5842 p
+= sizeof (Elf32_External_Rel
);
5844 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5845 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5846 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5847 p
+= sizeof (Elf32_External_Rel
);
5853 if (htab
->elf
.sgotplt
)
5855 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5858 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5862 /* Fill in the first three entries in the global offset table. */
5863 if (htab
->elf
.sgotplt
->size
> 0)
5865 bfd_put_32 (output_bfd
,
5867 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5868 htab
->elf
.sgotplt
->contents
);
5869 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5870 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5873 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5876 /* Adjust .eh_frame for .plt section. */
5877 if (htab
->plt_eh_frame
!= NULL
5878 && htab
->plt_eh_frame
->contents
!= NULL
)
5880 if (htab
->elf
.splt
!= NULL
5881 && htab
->elf
.splt
->size
!= 0
5882 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5883 && htab
->elf
.splt
->output_section
!= NULL
5884 && htab
->plt_eh_frame
->output_section
!= NULL
)
5886 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5887 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5888 + htab
->plt_eh_frame
->output_offset
5889 + PLT_FDE_START_OFFSET
;
5890 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5891 htab
->plt_eh_frame
->contents
5892 + PLT_FDE_START_OFFSET
);
5894 if (htab
->plt_eh_frame
->sec_info_type
5895 == SEC_INFO_TYPE_EH_FRAME
)
5897 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5899 htab
->plt_eh_frame
->contents
))
5904 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5905 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5907 /* Fill PLT entries for undefined weak symbols in PIE. */
5908 if (bfd_link_pie (info
))
5909 bfd_hash_traverse (&info
->hash
->table
,
5910 elf_i386_pie_finish_undefweak_symbol
,
5916 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5917 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5918 It has to be done before elf_link_sort_relocs is called so that
5919 dynamic relocations are properly sorted. */
5922 elf_i386_output_arch_local_syms
5923 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5924 struct bfd_link_info
*info
,
5925 void *flaginfo ATTRIBUTE_UNUSED
,
5926 int (*func
) (void *, const char *,
5929 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5931 struct elf_i386_link_hash_table
*htab
= elf_i386_hash_table (info
);
5935 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5936 htab_traverse (htab
->loc_hash_table
,
5937 elf_i386_finish_local_dynamic_symbol
,
5943 /* Return an array of PLT entry symbol values. */
5946 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5949 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5952 bfd_vma
*plt_sym_val
;
5954 bfd_byte
*plt_contents
;
5955 const struct elf_i386_backend_data
*bed
5956 = get_elf_i386_backend_data (abfd
);
5957 Elf_Internal_Shdr
*hdr
;
5959 /* Get the .plt section contents. */
5960 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5961 if (plt_contents
== NULL
)
5963 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5964 plt_contents
, 0, plt
->size
))
5967 free (plt_contents
);
5971 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5972 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5975 hdr
= &elf_section_data (relplt
)->this_hdr
;
5976 count
= relplt
->size
/ hdr
->sh_entsize
;
5978 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5979 if (plt_sym_val
== NULL
)
5982 for (i
= 0; i
< count
; i
++)
5983 plt_sym_val
[i
] = -1;
5985 plt_offset
= bed
->plt
->plt_entry_size
;
5986 p
= relplt
->relocation
;
5987 for (i
= 0; i
< count
; i
++, p
++)
5991 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5992 if (p
->howto
== NULL
)
5995 if (p
->howto
->type
!= R_386_JUMP_SLOT
5996 && p
->howto
->type
!= R_386_IRELATIVE
)
5999 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6000 + bed
->plt
->plt_reloc_offset
));
6001 reloc_index
/= sizeof (Elf32_External_Rel
);
6002 if (reloc_index
< count
)
6003 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6005 plt_offset
+= bed
->plt
->plt_entry_size
;
6007 /* PR binutils/18437: Skip extra relocations in the .rel.plt
6009 if (plt_offset
>= plt
->size
)
6013 free (plt_contents
);
6018 /* Similar to _bfd_elf_get_synthetic_symtab. */
6021 elf_i386_get_synthetic_symtab (bfd
*abfd
,
6028 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
6029 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6030 dynsymcount
, dynsyms
, ret
,
6032 elf_i386_get_plt_sym_val
);
6035 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6038 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
6040 if (h
->plt
.offset
!= (bfd_vma
) -1
6042 && !h
->pointer_equality_needed
)
6045 return _bfd_elf_hash_symbol (h
);
6048 #define TARGET_LITTLE_SYM i386_elf32_vec
6049 #define TARGET_LITTLE_NAME "elf32-i386"
6050 #define ELF_ARCH bfd_arch_i386
6051 #define ELF_TARGET_ID I386_ELF_DATA
6052 #define ELF_MACHINE_CODE EM_386
6053 #define ELF_MAXPAGESIZE 0x1000
6055 #define elf_backend_can_gc_sections 1
6056 #define elf_backend_can_refcount 1
6057 #define elf_backend_want_got_plt 1
6058 #define elf_backend_plt_readonly 1
6059 #define elf_backend_want_plt_sym 0
6060 #define elf_backend_got_header_size 12
6061 #define elf_backend_plt_alignment 4
6062 #define elf_backend_extern_protected_data 1
6063 #define elf_backend_caches_rawsize 1
6065 /* Support RELA for objdump of prelink objects. */
6066 #define elf_info_to_howto elf_i386_info_to_howto_rel
6067 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6069 #define bfd_elf32_mkobject elf_i386_mkobject
6071 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6072 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6073 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6074 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6075 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6077 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6078 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6079 #define elf_backend_check_relocs elf_i386_check_relocs
6080 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6081 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
6082 #define elf_backend_fake_sections elf_i386_fake_sections
6083 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6084 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6085 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6086 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6087 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6088 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6089 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6090 #define elf_backend_relocate_section elf_i386_relocate_section
6091 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6092 #define elf_backend_always_size_sections elf_i386_always_size_sections
6093 #define elf_backend_omit_section_dynsym \
6094 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6095 #define elf_backend_hash_symbol elf_i386_hash_symbol
6096 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6098 #include "elf32-target.h"
6100 /* FreeBSD support. */
6102 #undef TARGET_LITTLE_SYM
6103 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6104 #undef TARGET_LITTLE_NAME
6105 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6107 #define ELF_OSABI ELFOSABI_FREEBSD
6109 /* The kernel recognizes executables as valid only if they carry a
6110 "FreeBSD" label in the ELF header. So we put this label on all
6111 executables and (for simplicity) also all other object files. */
6114 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
6116 _bfd_elf_post_process_headers (abfd
, info
);
6118 #ifdef OLD_FREEBSD_ABI_LABEL
6120 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6121 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6122 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
6127 #undef elf_backend_post_process_headers
6128 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6130 #define elf32_bed elf32_i386_fbsd_bed
6132 #undef elf_backend_add_symbol_hook
6134 #include "elf32-target.h"
6138 #undef TARGET_LITTLE_SYM
6139 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6140 #undef TARGET_LITTLE_NAME
6141 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6143 #undef elf_backend_post_process_headers
6145 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6146 objects won't be recognized. */
6150 #define elf32_bed elf32_i386_sol2_bed
6152 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6154 #undef elf_backend_static_tls_alignment
6155 #define elf_backend_static_tls_alignment 8
6157 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6159 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6161 #undef elf_backend_want_plt_sym
6162 #define elf_backend_want_plt_sym 1
6164 #undef elf_backend_strtab_flags
6165 #define elf_backend_strtab_flags SHF_STRINGS
6167 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6168 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6169 FALSE otherwise. ISECTION is the best guess matching section from the
6170 input bfd IBFD, but it might be NULL. */
6173 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6174 bfd
*obfd ATTRIBUTE_UNUSED
,
6175 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6176 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6178 /* PR 19938: FIXME: Need to add code for setting the sh_info
6179 and sh_link fields of Solaris specific section types. */
6182 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6183 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6185 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6187 The following values should be set:
6190 -----------------------------------------------------------------------------
6191 SHT_SUNW_ancillary The section header index of 0
6192 [0x6fffffee] the associated string table.
6194 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6195 [0x6ffffff0] the associated symbol table. section header index of
6197 SHT_SUNW_capchain table,
6200 SHT_SUNW_symsort The section header index of 0
6201 [0x6ffffff1] the associated symbol table.
6203 SHT_SUNW_tlssort The section header index of 0
6204 [0x6ffffff2] the associated symbol table.
6206 SHT_SUNW_LDYNSYM The section header index of One greater than the
6207 [0x6ffffff3] the associated string table. symbol table index of the
6208 This index is the same string last local symbol,
6209 table used by the SHT_DYNSYM STB_LOCAL. Since
6210 section. SHT_SUNW_LDYNSYM only
6211 contains local symbols,
6212 sh_info is equivalent to
6213 the number of symbols in
6216 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6217 [0x6ffffff5] the section header index of to named strings, the
6218 the associated section header index of
6219 SHT_SUNW_capinfo table, the associated string
6220 otherwise 0. table, otherwise 0.
6222 SHT_SUNW_move The section header index of 0
6223 [0x6ffffffa] the associated symbol table.
6228 SHT_SUNW_syminfo The section header index of The section header index
6229 [0x6ffffffc] the associated symbol table. of the associated
6232 SHT_SUNW_verdef The section header index of The number of version
6233 [0x6ffffffd] the associated string table. definitions within the
6236 SHT_SUNW_verneed The section header index of The number of version
6237 [0x6ffffffe] the associated string table. dependencies within the
6240 SHT_SUNW_versym The section header index of 0
6241 [0x6fffffff] the associated symbol table. */
6244 #undef elf_backend_copy_special_section_fields
6245 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6247 #include "elf32-target.h"
6249 /* Intel MCU support. */
6252 elf32_iamcu_elf_object_p (bfd
*abfd
)
6254 /* Set the right machine number for an IAMCU elf32 file. */
6255 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6259 #undef TARGET_LITTLE_SYM
6260 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6261 #undef TARGET_LITTLE_NAME
6262 #define TARGET_LITTLE_NAME "elf32-iamcu"
6264 #define ELF_ARCH bfd_arch_iamcu
6266 #undef ELF_MACHINE_CODE
6267 #define ELF_MACHINE_CODE EM_IAMCU
6272 #define elf32_bed elf32_iamcu_bed
6274 #undef elf_backend_object_p
6275 #define elf_backend_object_p elf32_iamcu_elf_object_p
6277 #undef elf_backend_static_tls_alignment
6279 #undef elf_backend_want_plt_sym
6280 #define elf_backend_want_plt_sym 0
6282 #undef elf_backend_strtab_flags
6283 #undef elf_backend_copy_special_section_fields
6285 #include "elf32-target.h"
6287 /* Restore defaults. */
6289 #define ELF_ARCH bfd_arch_i386
6290 #undef ELF_MACHINE_CODE
6291 #define ELF_MACHINE_CODE EM_386
6293 /* Native Client support. */
6295 #undef TARGET_LITTLE_SYM
6296 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6297 #undef TARGET_LITTLE_NAME
6298 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6300 #define elf32_bed elf32_i386_nacl_bed
6302 #undef ELF_MAXPAGESIZE
6303 #define ELF_MAXPAGESIZE 0x10000
6305 /* Restore defaults. */
6307 #undef elf_backend_want_plt_sym
6308 #define elf_backend_want_plt_sym 0
6309 #undef elf_backend_post_process_headers
6310 #undef elf_backend_static_tls_alignment
6312 /* NaCl uses substantially different PLT entries for the same effects. */
6314 #undef elf_backend_plt_alignment
6315 #define elf_backend_plt_alignment 5
6316 #define NACL_PLT_ENTRY_SIZE 64
6317 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6319 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6321 0xff, 0x35, /* pushl contents of address */
6322 0, 0, 0, 0, /* replaced with address of .got + 4. */
6323 0x8b, 0x0d, /* movl contents of address, %ecx */
6324 0, 0, 0, 0, /* replaced with address of .got + 8. */
6325 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6326 0xff, 0xe1 /* jmp *%ecx */
6329 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6331 0x8b, 0x0d, /* movl contents of address, %ecx */
6332 0, 0, 0, 0, /* replaced with GOT slot address. */
6333 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6334 0xff, 0xe1, /* jmp *%ecx */
6336 /* Pad to the next 32-byte boundary with nop instructions. */
6338 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6339 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6341 /* Lazy GOT entries point here (32-byte aligned). */
6342 0x68, /* pushl immediate */
6343 0, 0, 0, 0, /* replaced with reloc offset. */
6344 0xe9, /* jmp relative */
6345 0, 0, 0, 0, /* replaced with offset to .plt. */
6347 /* Pad to the next 32-byte boundary with nop instructions. */
6348 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6349 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6353 static const bfd_byte
6354 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6356 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6357 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6358 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6359 0xff, 0xe1, /* jmp *%ecx */
6361 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6362 so pad to that size with nop instructions. */
6363 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6366 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6368 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6369 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6370 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6371 0xff, 0xe1, /* jmp *%ecx */
6373 /* Pad to the next 32-byte boundary with nop instructions. */
6375 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6376 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6378 /* Lazy GOT entries point here (32-byte aligned). */
6379 0x68, /* pushl immediate */
6380 0, 0, 0, 0, /* replaced with offset into relocation table. */
6381 0xe9, /* jmp relative */
6382 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6384 /* Pad to the next 32-byte boundary with nop instructions. */
6385 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6386 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6390 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6392 #if (PLT_CIE_LENGTH != 20 \
6393 || PLT_FDE_LENGTH != 36 \
6394 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6395 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6396 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6398 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6399 0, 0, 0, 0, /* CIE ID */
6400 1, /* CIE version */
6401 'z', 'R', 0, /* Augmentation string */
6402 1, /* Code alignment factor */
6403 0x7c, /* Data alignment factor: -4 */
6404 8, /* Return address column */
6405 1, /* Augmentation size */
6406 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6407 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6408 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6409 DW_CFA_nop
, DW_CFA_nop
,
6411 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6412 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6413 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6414 0, 0, 0, 0, /* .plt size goes here */
6415 0, /* Augmentation size */
6416 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6417 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6418 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6419 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6420 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6421 13, /* Block length */
6422 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6423 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6424 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6425 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6426 DW_CFA_nop
, DW_CFA_nop
6429 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6431 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6432 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6433 2, /* plt0_got1_offset */
6434 8, /* plt0_got2_offset */
6435 elf_i386_nacl_plt_entry
, /* plt_entry */
6436 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6437 2, /* plt_got_offset */
6438 33, /* plt_reloc_offset */
6439 38, /* plt_plt_offset */
6440 32, /* plt_lazy_offset */
6441 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6442 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6443 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6444 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6447 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6449 &elf_i386_nacl_plt
, /* plt */
6450 0x90, /* plt0_pad_byte: nop insn */
6455 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6457 /* Set the right machine number for a NaCl i386 ELF32 file. */
6458 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6462 #undef elf_backend_arch_data
6463 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6465 #undef elf_backend_object_p
6466 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6467 #undef elf_backend_modify_segment_map
6468 #define elf_backend_modify_segment_map nacl_modify_segment_map
6469 #undef elf_backend_modify_program_headers
6470 #define elf_backend_modify_program_headers nacl_modify_program_headers
6471 #undef elf_backend_final_write_processing
6472 #define elf_backend_final_write_processing nacl_final_write_processing
6474 #include "elf32-target.h"
6476 /* Restore defaults. */
6477 #undef elf_backend_object_p
6478 #undef elf_backend_modify_segment_map
6479 #undef elf_backend_modify_program_headers
6480 #undef elf_backend_final_write_processing
6482 /* VxWorks support. */
6484 #undef TARGET_LITTLE_SYM
6485 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6486 #undef TARGET_LITTLE_NAME
6487 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6489 #undef elf_backend_plt_alignment
6490 #define elf_backend_plt_alignment 4
6492 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6494 &elf_i386_plt
, /* plt */
6495 0x90, /* plt0_pad_byte */
6499 #undef elf_backend_arch_data
6500 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6502 #undef elf_backend_relocs_compatible
6503 #undef elf_backend_add_symbol_hook
6504 #define elf_backend_add_symbol_hook \
6505 elf_vxworks_add_symbol_hook
6506 #undef elf_backend_link_output_symbol_hook
6507 #define elf_backend_link_output_symbol_hook \
6508 elf_vxworks_link_output_symbol_hook
6509 #undef elf_backend_emit_relocs
6510 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6511 #undef elf_backend_final_write_processing
6512 #define elf_backend_final_write_processing \
6513 elf_vxworks_final_write_processing
6514 #undef elf_backend_static_tls_alignment
6516 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6518 #undef elf_backend_want_plt_sym
6519 #define elf_backend_want_plt_sym 1
6522 #define elf32_bed elf32_i386_vxworks_bed
6524 #include "elf32-target.h"