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 /* xgettext:c-format */
387 _bfd_error_handler (_("%B: invalid relocation type %d"),
391 /* PR 17512: file: 0f67f69d. */
392 if (elf_howto_table
[indx
].type
!= r_type
)
394 return &elf_howto_table
[indx
];
398 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
400 Elf_Internal_Rela
*dst
)
402 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
403 cache_ptr
->howto
= elf_i386_rtype_to_howto (abfd
, r_type
);
406 /* Return whether a symbol name implies a local label. The UnixWare
407 2.1 cc generates temporary symbols that start with .X, so we
408 recognize them here. FIXME: do other SVR4 compilers also use .X?.
409 If so, we should move the .X recognition into
410 _bfd_elf_is_local_label_name. */
413 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
415 if (name
[0] == '.' && name
[1] == 'X')
418 return _bfd_elf_is_local_label_name (abfd
, name
);
421 /* Support for core dump NOTE sections. */
424 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
429 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
431 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
437 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
440 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
444 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
448 switch (note
->descsz
)
453 case 144: /* Linux/i386 */
455 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
458 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
468 /* Make a ".reg/999" section. */
469 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
470 size
, note
->descpos
+ offset
);
474 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
476 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
478 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
483 elf_tdata (abfd
)->core
->program
484 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
485 elf_tdata (abfd
)->core
->command
486 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
490 switch (note
->descsz
)
495 case 124: /* Linux/i386 elf_prpsinfo. */
496 elf_tdata (abfd
)->core
->pid
497 = bfd_get_32 (abfd
, note
->descdata
+ 12);
498 elf_tdata (abfd
)->core
->program
499 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
500 elf_tdata (abfd
)->core
->command
501 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
505 /* Note that for some reason, a spurious space is tacked
506 onto the end of the args in some (at least one anyway)
507 implementations, so strip it off if it exists. */
509 char *command
= elf_tdata (abfd
)->core
->command
;
510 int n
= strlen (command
);
512 if (0 < n
&& command
[n
- 1] == ' ')
513 command
[n
- 1] = '\0';
519 /* Functions for the i386 ELF linker.
521 In order to gain some understanding of code in this file without
522 knowing all the intricate details of the linker, note the
525 Functions named elf_i386_* are called by external routines, other
526 functions are only called locally. elf_i386_* functions appear
527 in this file more or less in the order in which they are called
528 from external routines. eg. elf_i386_check_relocs is called
529 early in the link process, elf_i386_finish_dynamic_sections is
530 one of the last functions. */
533 /* The name of the dynamic interpreter. This is put in the .interp
536 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
538 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
539 copying dynamic variables from a shared lib into an app's dynbss
540 section, and instead use a dynamic relocation to point into the
542 #define ELIMINATE_COPY_RELOCS 1
544 /* The size in bytes of an entry in the procedure linkage table. */
546 #define PLT_ENTRY_SIZE 16
548 /* The first entry in an absolute procedure linkage table looks like
549 this. See the SVR4 ABI i386 supplement to see how this works.
550 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
552 static const bfd_byte elf_i386_plt0_entry
[12] =
554 0xff, 0x35, /* pushl contents of address */
555 0, 0, 0, 0, /* replaced with address of .got + 4. */
556 0xff, 0x25, /* jmp indirect */
557 0, 0, 0, 0 /* replaced with address of .got + 8. */
560 /* Subsequent entries in an absolute procedure linkage table look like
563 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
565 0xff, 0x25, /* jmp indirect */
566 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
567 0x68, /* pushl immediate */
568 0, 0, 0, 0, /* replaced with offset into relocation table. */
569 0xe9, /* jmp relative */
570 0, 0, 0, 0 /* replaced with offset to start of .plt. */
573 /* The first entry in a PIC procedure linkage table look like this.
574 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
576 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
578 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
579 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
582 /* Subsequent entries in a PIC procedure linkage table look like this. */
584 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
586 0xff, 0xa3, /* jmp *offset(%ebx) */
587 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
588 0x68, /* pushl immediate */
589 0, 0, 0, 0, /* replaced with offset into relocation table. */
590 0xe9, /* jmp relative */
591 0, 0, 0, 0 /* replaced with offset to start of .plt. */
594 /* Entries in the GOT procedure linkage table look like this. */
596 static const bfd_byte elf_i386_got_plt_entry
[8] =
598 0xff, 0x25, /* jmp indirect */
599 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries in the PIC GOT procedure linkage table look like this. */
605 static const bfd_byte elf_i386_pic_got_plt_entry
[8] =
607 0xff, 0xa3, /* jmp *offset(%ebx) */
608 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* .eh_frame covering the .plt section. */
614 static const bfd_byte elf_i386_eh_frame_plt
[] =
616 #define PLT_CIE_LENGTH 20
617 #define PLT_FDE_LENGTH 36
618 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
619 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
620 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
621 0, 0, 0, 0, /* CIE ID */
623 'z', 'R', 0, /* Augmentation string */
624 1, /* Code alignment factor */
625 0x7c, /* Data alignment factor */
626 8, /* Return address column */
627 1, /* Augmentation size */
628 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
629 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
630 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
631 DW_CFA_nop
, DW_CFA_nop
,
633 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
634 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
635 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
636 0, 0, 0, 0, /* .plt size goes here */
637 0, /* Augmentation size */
638 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
639 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
640 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
641 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
642 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
643 11, /* Block length */
644 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
645 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
646 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
647 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
648 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
651 struct elf_i386_plt_layout
653 /* The first entry in an absolute procedure linkage table looks like this. */
654 const bfd_byte
*plt0_entry
;
655 unsigned int plt0_entry_size
;
657 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
658 unsigned int plt0_got1_offset
;
659 unsigned int plt0_got2_offset
;
661 /* Later entries in an absolute procedure linkage table look like this. */
662 const bfd_byte
*plt_entry
;
663 unsigned int plt_entry_size
;
665 /* Offsets into plt_entry that are to be replaced with... */
666 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
667 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
668 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
670 /* Offset into plt_entry where the initial value of the GOT entry points. */
671 unsigned int plt_lazy_offset
;
673 /* The first entry in a PIC procedure linkage table looks like this. */
674 const bfd_byte
*pic_plt0_entry
;
676 /* Subsequent entries in a PIC procedure linkage table look like this. */
677 const bfd_byte
*pic_plt_entry
;
679 /* .eh_frame covering the .plt section. */
680 const bfd_byte
*eh_frame_plt
;
681 unsigned int eh_frame_plt_size
;
684 #define GET_PLT_ENTRY_SIZE(abfd) \
685 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
687 /* These are the standard parameters. */
688 static const struct elf_i386_plt_layout elf_i386_plt
=
690 elf_i386_plt0_entry
, /* plt0_entry */
691 sizeof (elf_i386_plt0_entry
), /* plt0_entry_size */
692 2, /* plt0_got1_offset */
693 8, /* plt0_got2_offset */
694 elf_i386_plt_entry
, /* plt_entry */
695 PLT_ENTRY_SIZE
, /* plt_entry_size */
696 2, /* plt_got_offset */
697 7, /* plt_reloc_offset */
698 12, /* plt_plt_offset */
699 6, /* plt_lazy_offset */
700 elf_i386_pic_plt0_entry
, /* pic_plt0_entry */
701 elf_i386_pic_plt_entry
, /* pic_plt_entry */
702 elf_i386_eh_frame_plt
, /* eh_frame_plt */
703 sizeof (elf_i386_eh_frame_plt
), /* eh_frame_plt_size */
707 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
708 for the PLTResolve stub and then for each PLT entry. */
709 #define PLTRESOLVE_RELOCS_SHLIB 0
710 #define PLTRESOLVE_RELOCS 2
711 #define PLT_NON_JUMP_SLOT_RELOCS 2
713 /* Architecture-specific backend data for i386. */
715 struct elf_i386_backend_data
717 /* Parameters describing PLT generation. */
718 const struct elf_i386_plt_layout
*plt
;
720 /* Value used to fill the unused bytes of the first PLT entry. */
721 bfd_byte plt0_pad_byte
;
723 /* True if the target system is VxWorks. */
727 #define get_elf_i386_backend_data(abfd) \
728 ((const struct elf_i386_backend_data *) \
729 get_elf_backend_data (abfd)->arch_data)
731 /* These are the standard parameters. */
732 static const struct elf_i386_backend_data elf_i386_arch_bed
=
734 &elf_i386_plt
, /* plt */
735 0, /* plt0_pad_byte */
739 #define elf_backend_arch_data &elf_i386_arch_bed
741 /* Is a undefined weak symbol which is resolved to 0. Reference to an
742 undefined weak symbol is resolved to 0 when building executable if
744 1. Has non-GOT/non-PLT relocations in text section. Or
745 2. Has no GOT/PLT relocation.
747 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
748 ((EH)->elf.root.type == bfd_link_hash_undefweak \
749 && bfd_link_executable (INFO) \
750 && (elf_i386_hash_table (INFO)->interp == NULL \
752 || (EH)->has_non_got_reloc \
753 || !(INFO)->dynamic_undefined_weak))
755 /* i386 ELF linker hash entry. */
757 struct elf_i386_link_hash_entry
759 struct elf_link_hash_entry elf
;
761 /* Track dynamic relocs copied for this symbol. */
762 struct elf_dyn_relocs
*dyn_relocs
;
764 #define GOT_UNKNOWN 0
768 #define GOT_TLS_IE_POS 5
769 #define GOT_TLS_IE_NEG 6
770 #define GOT_TLS_IE_BOTH 7
771 #define GOT_TLS_GDESC 8
772 #define GOT_TLS_GD_BOTH_P(type) \
773 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
774 #define GOT_TLS_GD_P(type) \
775 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
776 #define GOT_TLS_GDESC_P(type) \
777 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
778 #define GOT_TLS_GD_ANY_P(type) \
779 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
780 unsigned char tls_type
;
782 /* Symbol is referenced by R_386_GOTOFF relocation. */
783 unsigned int gotoff_ref
: 1;
785 /* Symbol has GOT or PLT relocations. */
786 unsigned int has_got_reloc
: 1;
788 /* Symbol has non-GOT/non-PLT relocations in text sections. */
789 unsigned int has_non_got_reloc
: 1;
791 /* 0: symbol isn't ___tls_get_addr.
792 1: symbol is ___tls_get_addr.
793 2: symbol is unknown. */
794 unsigned int tls_get_addr
: 2;
796 /* Reference count of C/C++ function pointer relocations in read-write
797 section which can be resolved at run-time. */
798 bfd_signed_vma func_pointer_refcount
;
800 /* Information about the GOT PLT entry. Filled when there are both
801 GOT and PLT relocations against the same function. */
802 union gotplt_union plt_got
;
804 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
805 starting at the end of the jump table. */
809 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
811 struct elf_i386_obj_tdata
813 struct elf_obj_tdata root
;
815 /* tls_type for each local got entry. */
816 char *local_got_tls_type
;
818 /* GOTPLT entries for TLS descriptors. */
819 bfd_vma
*local_tlsdesc_gotent
;
822 #define elf_i386_tdata(abfd) \
823 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
825 #define elf_i386_local_got_tls_type(abfd) \
826 (elf_i386_tdata (abfd)->local_got_tls_type)
828 #define elf_i386_local_tlsdesc_gotent(abfd) \
829 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
831 #define is_i386_elf(bfd) \
832 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
833 && elf_tdata (bfd) != NULL \
834 && elf_object_id (bfd) == I386_ELF_DATA)
837 elf_i386_mkobject (bfd
*abfd
)
839 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_i386_obj_tdata
),
843 /* i386 ELF linker hash table. */
845 struct elf_i386_link_hash_table
847 struct elf_link_hash_table elf
;
849 /* Short-cuts to get to dynamic linker sections. */
853 asection
*plt_eh_frame
;
858 bfd_signed_vma refcount
;
862 /* The amount of space used by the reserved portion of the sgotplt
863 section, plus whatever space is used by the jump slots. */
864 bfd_vma sgotplt_jump_table_size
;
866 /* Small local sym cache. */
867 struct sym_cache sym_cache
;
869 /* _TLS_MODULE_BASE_ symbol. */
870 struct bfd_link_hash_entry
*tls_module_base
;
872 /* Used by local STT_GNU_IFUNC symbols. */
873 htab_t loc_hash_table
;
874 void * loc_hash_memory
;
876 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
879 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
880 bfd_vma next_tls_desc_index
;
882 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
883 bfd_vma next_jump_slot_index
;
885 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
886 bfd_vma next_irelative_index
;
888 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
889 to read-only sections. */
890 bfd_boolean readonly_dynrelocs_against_ifunc
;
893 /* Get the i386 ELF linker hash table from a link_info structure. */
895 #define elf_i386_hash_table(p) \
896 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
897 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
899 #define elf_i386_compute_jump_table_size(htab) \
900 ((htab)->elf.srelplt->reloc_count * 4)
902 /* Create an entry in an i386 ELF linker hash table. */
904 static struct bfd_hash_entry
*
905 elf_i386_link_hash_newfunc (struct bfd_hash_entry
*entry
,
906 struct bfd_hash_table
*table
,
909 /* Allocate the structure if it has not already been allocated by a
913 entry
= (struct bfd_hash_entry
*)
914 bfd_hash_allocate (table
, sizeof (struct elf_i386_link_hash_entry
));
919 /* Call the allocation method of the superclass. */
920 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
923 struct elf_i386_link_hash_entry
*eh
;
925 eh
= (struct elf_i386_link_hash_entry
*) entry
;
926 eh
->dyn_relocs
= NULL
;
927 eh
->tls_type
= GOT_UNKNOWN
;
929 eh
->has_got_reloc
= 0;
930 eh
->has_non_got_reloc
= 0;
931 eh
->tls_get_addr
= 2;
932 eh
->func_pointer_refcount
= 0;
933 eh
->plt_got
.offset
= (bfd_vma
) -1;
934 eh
->tlsdesc_got
= (bfd_vma
) -1;
940 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
941 for local symbol so that we can handle local STT_GNU_IFUNC symbols
942 as global symbol. We reuse indx and dynstr_index for local symbol
943 hash since they aren't used by global symbols in this backend. */
946 elf_i386_local_htab_hash (const void *ptr
)
948 struct elf_link_hash_entry
*h
949 = (struct elf_link_hash_entry
*) ptr
;
950 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
953 /* Compare local hash entries. */
956 elf_i386_local_htab_eq (const void *ptr1
, const void *ptr2
)
958 struct elf_link_hash_entry
*h1
959 = (struct elf_link_hash_entry
*) ptr1
;
960 struct elf_link_hash_entry
*h2
961 = (struct elf_link_hash_entry
*) ptr2
;
963 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
966 /* Find and/or create a hash entry for local symbol. */
968 static struct elf_link_hash_entry
*
969 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table
*htab
,
970 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
973 struct elf_i386_link_hash_entry e
, *ret
;
974 asection
*sec
= abfd
->sections
;
975 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
976 ELF32_R_SYM (rel
->r_info
));
979 e
.elf
.indx
= sec
->id
;
980 e
.elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
981 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
982 create
? INSERT
: NO_INSERT
);
989 ret
= (struct elf_i386_link_hash_entry
*) *slot
;
993 ret
= (struct elf_i386_link_hash_entry
*)
994 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
995 sizeof (struct elf_i386_link_hash_entry
));
998 memset (ret
, 0, sizeof (*ret
));
999 ret
->elf
.indx
= sec
->id
;
1000 ret
->elf
.dynstr_index
= ELF32_R_SYM (rel
->r_info
);
1001 ret
->elf
.dynindx
= -1;
1002 ret
->func_pointer_refcount
= 0;
1003 ret
->plt_got
.offset
= (bfd_vma
) -1;
1009 /* Destroy an i386 ELF linker hash table. */
1012 elf_i386_link_hash_table_free (bfd
*obfd
)
1014 struct elf_i386_link_hash_table
*htab
1015 = (struct elf_i386_link_hash_table
*) obfd
->link
.hash
;
1017 if (htab
->loc_hash_table
)
1018 htab_delete (htab
->loc_hash_table
);
1019 if (htab
->loc_hash_memory
)
1020 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1021 _bfd_elf_link_hash_table_free (obfd
);
1024 /* Create an i386 ELF linker hash table. */
1026 static struct bfd_link_hash_table
*
1027 elf_i386_link_hash_table_create (bfd
*abfd
)
1029 struct elf_i386_link_hash_table
*ret
;
1030 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
1032 ret
= (struct elf_i386_link_hash_table
*) bfd_zmalloc (amt
);
1036 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1037 elf_i386_link_hash_newfunc
,
1038 sizeof (struct elf_i386_link_hash_entry
),
1045 ret
->loc_hash_table
= htab_try_create (1024,
1046 elf_i386_local_htab_hash
,
1047 elf_i386_local_htab_eq
,
1049 ret
->loc_hash_memory
= objalloc_create ();
1050 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1052 elf_i386_link_hash_table_free (abfd
);
1055 ret
->elf
.root
.hash_table_free
= elf_i386_link_hash_table_free
;
1057 return &ret
->elf
.root
;
1060 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1061 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1065 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1067 struct elf_i386_link_hash_table
*htab
;
1069 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1072 htab
= elf_i386_hash_table (info
);
1076 /* Set the contents of the .interp section to the interpreter. */
1077 if (bfd_link_executable (info
) && !info
->nointerp
)
1079 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1082 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1083 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1087 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1091 if (bfd_link_executable (info
))
1093 /* Always allow copy relocs for building executables. */
1094 asection
*s
= bfd_get_linker_section (dynobj
, ".rel.bss");
1097 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1098 s
= bfd_make_section_anyway_with_flags (dynobj
,
1100 (bed
->dynamic_sec_flags
1103 || ! bfd_set_section_alignment (dynobj
, s
,
1104 bed
->s
->log_file_align
))
1110 if (get_elf_i386_backend_data (dynobj
)->is_vxworks
1111 && !elf_vxworks_create_dynamic_sections (dynobj
, info
,
1115 if (!info
->no_ld_generated_unwind_info
1116 && htab
->plt_eh_frame
== NULL
1117 && htab
->elf
.splt
!= NULL
)
1119 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1120 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1121 | SEC_LINKER_CREATED
);
1123 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1124 if (htab
->plt_eh_frame
== NULL
1125 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 2))
1132 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1135 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
1136 struct elf_link_hash_entry
*dir
,
1137 struct elf_link_hash_entry
*ind
)
1139 struct elf_i386_link_hash_entry
*edir
, *eind
;
1141 edir
= (struct elf_i386_link_hash_entry
*) dir
;
1142 eind
= (struct elf_i386_link_hash_entry
*) ind
;
1144 if (eind
->dyn_relocs
!= NULL
)
1146 if (edir
->dyn_relocs
!= NULL
)
1148 struct elf_dyn_relocs
**pp
;
1149 struct elf_dyn_relocs
*p
;
1151 /* Add reloc counts against the indirect sym to the direct sym
1152 list. Merge any entries against the same section. */
1153 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1155 struct elf_dyn_relocs
*q
;
1157 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1158 if (q
->sec
== p
->sec
)
1160 q
->pc_count
+= p
->pc_count
;
1161 q
->count
+= p
->count
;
1168 *pp
= edir
->dyn_relocs
;
1171 edir
->dyn_relocs
= eind
->dyn_relocs
;
1172 eind
->dyn_relocs
= NULL
;
1175 if (ind
->root
.type
== bfd_link_hash_indirect
1176 && dir
->got
.refcount
<= 0)
1178 edir
->tls_type
= eind
->tls_type
;
1179 eind
->tls_type
= GOT_UNKNOWN
;
1182 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1183 generate a R_386_COPY reloc. */
1184 edir
->gotoff_ref
|= eind
->gotoff_ref
;
1186 edir
->has_got_reloc
|= eind
->has_got_reloc
;
1187 edir
->has_non_got_reloc
|= eind
->has_non_got_reloc
;
1189 if (ELIMINATE_COPY_RELOCS
1190 && ind
->root
.type
!= bfd_link_hash_indirect
1191 && dir
->dynamic_adjusted
)
1193 /* If called to transfer flags for a weakdef during processing
1194 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1195 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1196 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1197 dir
->ref_regular
|= ind
->ref_regular
;
1198 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1199 dir
->needs_plt
|= ind
->needs_plt
;
1200 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1204 if (eind
->func_pointer_refcount
> 0)
1206 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1207 eind
->func_pointer_refcount
= 0;
1210 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1214 /* Return TRUE if the TLS access code sequence support transition
1218 elf_i386_check_tls_transition (asection
*sec
,
1220 Elf_Internal_Shdr
*symtab_hdr
,
1221 struct elf_link_hash_entry
**sym_hashes
,
1222 unsigned int r_type
,
1223 const Elf_Internal_Rela
*rel
,
1224 const Elf_Internal_Rela
*relend
)
1226 unsigned int val
, type
, reg
;
1227 unsigned long r_symndx
;
1228 struct elf_link_hash_entry
*h
;
1231 bfd_boolean indirect_call
, tls_get_addr
;
1233 offset
= rel
->r_offset
;
1238 if (offset
< 2 || (rel
+ 1) >= relend
)
1241 indirect_call
= FALSE
;
1242 call
= contents
+ offset
+ 4;
1245 if (r_type
== R_386_TLS_GD
)
1247 /* Check transition from GD access model. Only
1248 leal foo@tlsgd(,%ebx,1), %eax
1249 call ___tls_get_addr@PLT
1251 leal foo@tlsgd(%ebx) %eax
1252 call ___tls_get_addr@PLT
1255 leal foo@tlsgd(%reg), %eax
1256 call *___tls_get_addr@GOT(%reg)
1257 which may be converted to
1258 addr32 call ___tls_get_addr
1259 can transit to different access model. */
1260 if ((offset
+ 10) > sec
->size
1261 || (type
!= 0x8d && type
!= 0x04))
1266 /* leal foo@tlsgd(,%ebx,1), %eax
1267 call ___tls_get_addr@PLT */
1271 if (*(call
- 7) != 0x8d
1279 leal foo@tlsgd(%ebx), %eax
1280 call ___tls_get_addr@PLT
1283 leal foo@tlsgd(%reg), %eax
1284 call *___tls_get_addr@GOT(%reg)
1285 which may be converted to
1286 addr32 call ___tls_get_addr
1288 %eax can't be used as the GOT base register since it
1289 is used to pass parameter to ___tls_get_addr. */
1291 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1294 indirect_call
= call
[0] == 0xff;
1295 if (!(reg
== 3 && call
[0] == 0xe8 && call
[5] == 0x90)
1296 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1298 && (call
[1] & 0xf8) == 0x90
1299 && (call
[1] & 0x7) == reg
))
1305 /* Check transition from LD access model. Only
1306 leal foo@tlsldm(%ebx), %eax
1307 call ___tls_get_addr@PLT
1309 leal foo@tlsldm(%reg), %eax
1310 call *___tls_get_addr@GOT(%reg)
1311 which may be converted to
1312 addr32 call ___tls_get_addr
1313 can transit to different access model. */
1314 if (type
!= 0x8d || (offset
+ 9) > sec
->size
)
1317 /* %eax can't be used as the GOT base register since it is
1318 used to pass parameter to ___tls_get_addr. */
1320 if ((val
& 0xf8) != 0x80 || reg
== 4 || reg
== 0)
1323 indirect_call
= call
[0] == 0xff;
1324 if (!(reg
== 3 && call
[0] == 0xe8)
1325 && !(call
[0] == 0x67 && call
[1] == 0xe8)
1327 && (call
[1] & 0xf8) == 0x90
1328 && (call
[1] & 0x7) == reg
))
1332 r_symndx
= ELF32_R_SYM (rel
[1].r_info
);
1333 if (r_symndx
< symtab_hdr
->sh_info
)
1336 tls_get_addr
= FALSE
;
1337 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1338 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1340 struct elf_i386_link_hash_entry
*eh
1341 = (struct elf_i386_link_hash_entry
*) h
;
1342 tls_get_addr
= eh
->tls_get_addr
== 1;
1343 if (eh
->tls_get_addr
> 1)
1345 /* Use strncmp to check ___tls_get_addr since
1346 ___tls_get_addr may be versioned. */
1347 if (strncmp (h
->root
.root
.string
, "___tls_get_addr", 15)
1350 eh
->tls_get_addr
= 1;
1351 tls_get_addr
= TRUE
;
1354 eh
->tls_get_addr
= 0;
1360 else if (indirect_call
)
1361 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_GOT32X
);
1363 return (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PC32
1364 || ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
1367 /* Check transition from IE access model:
1368 movl foo@indntpoff(%rip), %eax
1369 movl foo@indntpoff(%rip), %reg
1370 addl foo@indntpoff(%rip), %reg
1373 if (offset
< 1 || (offset
+ 4) > sec
->size
)
1376 /* Check "movl foo@tpoff(%rip), %eax" first. */
1377 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1384 /* Check movl|addl foo@tpoff(%rip), %reg. */
1385 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1386 return ((type
== 0x8b || type
== 0x03)
1387 && (val
& 0xc7) == 0x05);
1389 case R_386_TLS_GOTIE
:
1390 case R_386_TLS_IE_32
:
1391 /* Check transition from {IE_32,GOTIE} access model:
1392 subl foo@{tpoff,gontoff}(%reg1), %reg2
1393 movl foo@{tpoff,gontoff}(%reg1), %reg2
1394 addl foo@{tpoff,gontoff}(%reg1), %reg2
1397 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1400 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1401 if ((val
& 0xc0) != 0x80 || (val
& 7) == 4)
1404 type
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1405 return type
== 0x8b || type
== 0x2b || type
== 0x03;
1407 case R_386_TLS_GOTDESC
:
1408 /* Check transition from GDesc access model:
1409 leal x@tlsdesc(%ebx), %eax
1411 Make sure it's a leal adding ebx to a 32-bit offset
1412 into any register, although it's probably almost always
1415 if (offset
< 2 || (offset
+ 4) > sec
->size
)
1418 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1421 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1422 return (val
& 0xc7) == 0x83;
1424 case R_386_TLS_DESC_CALL
:
1425 /* Check transition from GDesc access model:
1426 call *x@tlsdesc(%eax)
1428 if (offset
+ 2 <= sec
->size
)
1430 /* Make sure that it's a call *x@tlsdesc(%eax). */
1431 call
= contents
+ offset
;
1432 return call
[0] == 0xff && call
[1] == 0x10;
1442 /* Return TRUE if the TLS access transition is OK or no transition
1443 will be performed. Update R_TYPE if there is a transition. */
1446 elf_i386_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1447 asection
*sec
, bfd_byte
*contents
,
1448 Elf_Internal_Shdr
*symtab_hdr
,
1449 struct elf_link_hash_entry
**sym_hashes
,
1450 unsigned int *r_type
, int tls_type
,
1451 const Elf_Internal_Rela
*rel
,
1452 const Elf_Internal_Rela
*relend
,
1453 struct elf_link_hash_entry
*h
,
1454 unsigned long r_symndx
,
1455 bfd_boolean from_relocate_section
)
1457 unsigned int from_type
= *r_type
;
1458 unsigned int to_type
= from_type
;
1459 bfd_boolean check
= TRUE
;
1461 /* Skip TLS transition for functions. */
1463 && (h
->type
== STT_FUNC
1464 || h
->type
== STT_GNU_IFUNC
))
1470 case R_386_TLS_GOTDESC
:
1471 case R_386_TLS_DESC_CALL
:
1472 case R_386_TLS_IE_32
:
1474 case R_386_TLS_GOTIE
:
1475 if (bfd_link_executable (info
))
1478 to_type
= R_386_TLS_LE_32
;
1479 else if (from_type
!= R_386_TLS_IE
1480 && from_type
!= R_386_TLS_GOTIE
)
1481 to_type
= R_386_TLS_IE_32
;
1484 /* When we are called from elf_i386_relocate_section, there may
1485 be additional transitions based on TLS_TYPE. */
1486 if (from_relocate_section
)
1488 unsigned int new_to_type
= to_type
;
1490 if (bfd_link_executable (info
)
1493 && (tls_type
& GOT_TLS_IE
))
1494 new_to_type
= R_386_TLS_LE_32
;
1496 if (to_type
== R_386_TLS_GD
1497 || to_type
== R_386_TLS_GOTDESC
1498 || to_type
== R_386_TLS_DESC_CALL
)
1500 if (tls_type
== GOT_TLS_IE_POS
)
1501 new_to_type
= R_386_TLS_GOTIE
;
1502 else if (tls_type
& GOT_TLS_IE
)
1503 new_to_type
= R_386_TLS_IE_32
;
1506 /* We checked the transition before when we were called from
1507 elf_i386_check_relocs. We only want to check the new
1508 transition which hasn't been checked before. */
1509 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1510 to_type
= new_to_type
;
1516 if (bfd_link_executable (info
))
1517 to_type
= R_386_TLS_LE_32
;
1524 /* Return TRUE if there is no transition. */
1525 if (from_type
== to_type
)
1528 /* Check if the transition can be performed. */
1530 && ! elf_i386_check_tls_transition (sec
, contents
,
1531 symtab_hdr
, sym_hashes
,
1532 from_type
, rel
, relend
))
1534 reloc_howto_type
*from
, *to
;
1537 from
= elf_i386_rtype_to_howto (abfd
, from_type
);
1538 to
= elf_i386_rtype_to_howto (abfd
, to_type
);
1541 name
= h
->root
.root
.string
;
1544 struct elf_i386_link_hash_table
*htab
;
1546 htab
= elf_i386_hash_table (info
);
1551 Elf_Internal_Sym
*isym
;
1553 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1555 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1560 /* xgettext:c-format */
1561 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1562 "in section `%A' failed"),
1563 abfd
, sec
, from
->name
, to
->name
, name
,
1564 (unsigned long) rel
->r_offset
);
1565 bfd_set_error (bfd_error_bad_value
);
1573 /* With the local symbol, foo, we convert
1574 mov foo@GOT[(%reg1)], %reg2
1576 lea foo[@GOTOFF(%reg1)], %reg2
1578 call/jmp *foo@GOT[(%reg)]
1580 nop call foo/jmp foo nop
1581 When PIC is false, convert
1582 test %reg1, foo@GOT[(%reg2)]
1586 binop foo@GOT[(%reg1)], %reg2
1589 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1594 elf_i386_convert_load_reloc (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
1596 Elf_Internal_Rela
*irel
,
1597 struct elf_link_hash_entry
*h
,
1598 bfd_boolean
*converted
,
1599 struct bfd_link_info
*link_info
)
1601 struct elf_i386_link_hash_table
*htab
;
1602 unsigned int opcode
;
1604 bfd_boolean baseless
;
1605 Elf_Internal_Sym
*isym
;
1606 unsigned int addend
;
1610 bfd_boolean to_reloc_32
;
1611 unsigned int r_type
;
1612 unsigned int r_symndx
;
1613 bfd_vma roff
= irel
->r_offset
;
1618 /* Addend for R_386_GOT32X relocations must be 0. */
1619 addend
= bfd_get_32 (abfd
, contents
+ roff
);
1623 htab
= elf_i386_hash_table (link_info
);
1624 is_pic
= bfd_link_pic (link_info
);
1626 r_type
= ELF32_R_TYPE (irel
->r_info
);
1627 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1629 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1630 baseless
= (modrm
& 0xc7) == 0x5;
1632 if (baseless
&& is_pic
)
1634 /* For PIC, disallow R_386_GOT32X without a base register
1635 since we don't know what the GOT base is. */
1640 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
,
1642 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1645 name
= h
->root
.root
.string
;
1648 /* xgettext:c-format */
1649 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1654 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1656 /* Convert to R_386_32 if PIC is false or there is no base
1658 to_reloc_32
= !is_pic
|| baseless
;
1660 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1664 if (opcode
== 0x0ff)
1665 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1666 goto convert_branch
;
1668 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1669 "test %reg1, foo@GOT(%reg2)" and
1670 "binop foo@GOT[(%reg1)], %reg2". */
1674 /* Undefined weak symbol is only bound locally in executable
1675 and its reference is resolved as 0. */
1676 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
, TRUE
,
1677 elf_i386_hash_entry (h
)))
1681 /* No direct branch to 0 for PIC. */
1685 goto convert_branch
;
1689 /* We can convert load of address 0 to R_386_32. */
1697 /* We have "call/jmp *foo@GOT[(%reg)]". */
1698 if ((h
->root
.type
== bfd_link_hash_defined
1699 || h
->root
.type
== bfd_link_hash_defweak
)
1700 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1702 /* The function is locally defined. */
1704 /* Convert R_386_GOT32X to R_386_PC32. */
1705 if (modrm
== 0x15 || (modrm
& 0xf8) == 0x90)
1707 struct elf_i386_link_hash_entry
*eh
1708 = (struct elf_i386_link_hash_entry
*) h
;
1710 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1713 /* To support TLS optimization, always use addr32 prefix
1714 for "call *___tls_get_addr@GOT(%reg)". */
1715 if (eh
&& eh
->tls_get_addr
== 1)
1718 nop_offset
= irel
->r_offset
- 2;
1722 nop
= link_info
->call_nop_byte
;
1723 if (link_info
->call_nop_as_suffix
)
1725 nop_offset
= roff
+ 3;
1726 irel
->r_offset
-= 1;
1729 nop_offset
= roff
- 2;
1734 /* Convert to "jmp foo nop". */
1737 nop_offset
= roff
+ 3;
1738 irel
->r_offset
-= 1;
1741 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1742 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1743 /* When converting to PC-relative relocation, we
1744 need to adjust addend by -4. */
1745 bfd_put_32 (abfd
, -4, contents
+ irel
->r_offset
);
1746 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_386_PC32
);
1753 /* We have "mov foo@GOT[(%re1g)], %reg2",
1754 "test %reg1, foo@GOT(%reg2)" and
1755 "binop foo@GOT[(%reg1)], %reg2".
1757 Avoid optimizing _DYNAMIC since ld.so may use its
1758 link-time address. */
1759 if (h
== htab
->elf
.hdynamic
)
1762 /* def_regular is set by an assignment in a linker script in
1763 bfd_elf_record_link_assignment. */
1765 || h
->root
.type
== bfd_link_hash_defined
1766 || h
->root
.type
== bfd_link_hash_defweak
)
1767 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1774 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1775 "mov $foo, %reg2" with R_386_32. */
1777 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1778 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1783 /* Convert "mov foo@GOT(%reg1), %reg2" to
1784 "lea foo@GOTOFF(%reg1), %reg2". */
1785 r_type
= R_386_GOTOFF
;
1791 /* Only R_386_32 is supported. */
1797 /* Convert "test %reg1, foo@GOT(%reg2)" to
1798 "test $foo, %reg1". */
1799 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1804 /* Convert "binop foo@GOT(%reg1), %reg2" to
1805 "binop $foo, %reg2". */
1807 | (modrm
& 0x38) >> 3
1811 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1815 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1816 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
1825 /* Rename some of the generic section flags to better document how they
1827 #define need_convert_load sec_flg0
1828 #define check_relocs_failed sec_flg1
1830 /* Look through the relocs for a section during the first phase, and
1831 calculate needed space in the global offset table, procedure linkage
1832 table, and dynamic reloc sections. */
1835 elf_i386_check_relocs (bfd
*abfd
,
1836 struct bfd_link_info
*info
,
1838 const Elf_Internal_Rela
*relocs
)
1840 struct elf_i386_link_hash_table
*htab
;
1841 Elf_Internal_Shdr
*symtab_hdr
;
1842 struct elf_link_hash_entry
**sym_hashes
;
1843 const Elf_Internal_Rela
*rel
;
1844 const Elf_Internal_Rela
*rel_end
;
1847 bfd_boolean use_plt_got
;
1849 if (bfd_link_relocatable (info
))
1852 /* Don't do anything special with non-loaded, non-alloced sections.
1853 In particular, any relocs in such sections should not affect GOT
1854 and PLT reference counting (ie. we don't allow them to create GOT
1855 or PLT entries), there's no possibility or desire to optimize TLS
1856 relocs, and there's not much point in propagating relocs to shared
1857 libs that the dynamic linker won't relocate. */
1858 if ((sec
->flags
& SEC_ALLOC
) == 0)
1861 BFD_ASSERT (is_i386_elf (abfd
));
1863 htab
= elf_i386_hash_table (info
);
1866 sec
->check_relocs_failed
= 1;
1870 /* Get the section contents. */
1871 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1872 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1873 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1875 sec
->check_relocs_failed
= 1;
1879 use_plt_got
= (!get_elf_i386_backend_data (abfd
)->is_vxworks
1880 && (get_elf_i386_backend_data (abfd
)
1881 == &elf_i386_arch_bed
));
1883 symtab_hdr
= &elf_symtab_hdr (abfd
);
1884 sym_hashes
= elf_sym_hashes (abfd
);
1888 rel_end
= relocs
+ sec
->reloc_count
;
1889 for (rel
= relocs
; rel
< rel_end
; rel
++)
1891 unsigned int r_type
;
1892 unsigned long r_symndx
;
1893 struct elf_link_hash_entry
*h
;
1894 struct elf_i386_link_hash_entry
*eh
;
1895 Elf_Internal_Sym
*isym
;
1897 bfd_boolean size_reloc
;
1899 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1900 r_type
= ELF32_R_TYPE (rel
->r_info
);
1902 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1904 /* xgettext:c-format */
1905 _bfd_error_handler (_("%B: bad symbol index: %d"),
1910 if (r_symndx
< symtab_hdr
->sh_info
)
1912 /* A local symbol. */
1913 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1918 /* Check relocation against local STT_GNU_IFUNC symbol. */
1919 if (ELF32_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1921 h
= elf_i386_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
1925 /* Fake a STT_GNU_IFUNC symbol. */
1926 h
->type
= STT_GNU_IFUNC
;
1929 h
->forced_local
= 1;
1930 h
->root
.type
= bfd_link_hash_defined
;
1938 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1939 while (h
->root
.type
== bfd_link_hash_indirect
1940 || h
->root
.type
== bfd_link_hash_warning
)
1941 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1944 eh
= (struct elf_i386_link_hash_entry
*) h
;
1960 if (htab
->elf
.dynobj
== NULL
)
1961 htab
->elf
.dynobj
= abfd
;
1962 /* Create the ifunc sections for static executables. */
1963 if (h
->type
== STT_GNU_IFUNC
1964 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1970 /* It is referenced by a non-shared object. */
1972 h
->root
.non_ir_ref
= 1;
1974 if (h
->type
== STT_GNU_IFUNC
)
1975 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1976 |= elf_gnu_symbol_ifunc
;
1979 if (! elf_i386_tls_transition (info
, abfd
, sec
, contents
,
1980 symtab_hdr
, sym_hashes
,
1981 &r_type
, GOT_UNKNOWN
,
1982 rel
, rel_end
, h
, r_symndx
, FALSE
))
1988 htab
->tls_ldm_got
.refcount
+= 1;
1992 /* This symbol requires a procedure linkage table entry. We
1993 actually build the entry in adjust_dynamic_symbol,
1994 because this might be a case of linking PIC code which is
1995 never referenced by a dynamic object, in which case we
1996 don't need to generate a procedure linkage table entry
1999 /* If this is a local symbol, we resolve it directly without
2000 creating a procedure linkage table entry. */
2004 eh
->has_got_reloc
= 1;
2006 h
->plt
.refcount
+= 1;
2013 case R_386_TLS_IE_32
:
2015 case R_386_TLS_GOTIE
:
2016 if (!bfd_link_executable (info
))
2017 info
->flags
|= DF_STATIC_TLS
;
2023 case R_386_TLS_GOTDESC
:
2024 case R_386_TLS_DESC_CALL
:
2025 /* This symbol requires a global offset table entry. */
2027 int tls_type
, old_tls_type
;
2034 tls_type
= GOT_NORMAL
;
2036 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
2037 case R_386_TLS_GOTDESC
:
2038 case R_386_TLS_DESC_CALL
:
2039 tls_type
= GOT_TLS_GDESC
; break;
2040 case R_386_TLS_IE_32
:
2041 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
2042 tls_type
= GOT_TLS_IE_NEG
;
2044 /* If this is a GD->IE transition, we may use either of
2045 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2046 tls_type
= GOT_TLS_IE
;
2049 case R_386_TLS_GOTIE
:
2050 tls_type
= GOT_TLS_IE_POS
; break;
2055 h
->got
.refcount
+= 1;
2056 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2060 bfd_signed_vma
*local_got_refcounts
;
2062 /* This is a global offset table entry for a local symbol. */
2063 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2064 if (local_got_refcounts
== NULL
)
2068 size
= symtab_hdr
->sh_info
;
2069 size
*= (sizeof (bfd_signed_vma
)
2070 + sizeof (bfd_vma
) + sizeof(char));
2071 local_got_refcounts
= (bfd_signed_vma
*)
2072 bfd_zalloc (abfd
, size
);
2073 if (local_got_refcounts
== NULL
)
2075 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2076 elf_i386_local_tlsdesc_gotent (abfd
)
2077 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2078 elf_i386_local_got_tls_type (abfd
)
2079 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2081 local_got_refcounts
[r_symndx
] += 1;
2082 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
2085 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
2086 tls_type
|= old_tls_type
;
2087 /* If a TLS symbol is accessed using IE at least once,
2088 there is no point to use dynamic model for it. */
2089 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2090 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2091 || (tls_type
& GOT_TLS_IE
) == 0))
2093 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
2094 tls_type
= old_tls_type
;
2095 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2096 && GOT_TLS_GD_ANY_P (tls_type
))
2097 tls_type
|= old_tls_type
;
2101 name
= h
->root
.root
.string
;
2103 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2106 /* xgettext:c-format */
2107 (_("%B: `%s' accessed both as normal and "
2108 "thread local symbol"),
2110 bfd_set_error (bfd_error_bad_value
);
2115 if (old_tls_type
!= tls_type
)
2118 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
2120 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2128 if (htab
->elf
.sgot
== NULL
)
2130 if (htab
->elf
.dynobj
== NULL
)
2131 htab
->elf
.dynobj
= abfd
;
2132 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
2135 if (r_type
!= R_386_TLS_IE
)
2138 eh
->has_got_reloc
= 1;
2143 case R_386_TLS_LE_32
:
2146 eh
->has_got_reloc
= 1;
2147 if (bfd_link_executable (info
))
2149 info
->flags
|= DF_STATIC_TLS
;
2154 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2155 eh
->has_non_got_reloc
= 1;
2157 /* We are called after all symbols have been resolved. Only
2158 relocation against STT_GNU_IFUNC symbol must go through
2161 && (bfd_link_executable (info
)
2162 || h
->type
== STT_GNU_IFUNC
))
2164 /* If this reloc is in a read-only section, we might
2165 need a copy reloc. We can't check reliably at this
2166 stage whether the section is read-only, as input
2167 sections have not yet been mapped to output sections.
2168 Tentatively set the flag for now, and correct in
2169 adjust_dynamic_symbol. */
2172 /* We may need a .plt entry if the symbol is a function
2173 defined in a shared lib or is a STT_GNU_IFUNC function
2174 referenced from the code or read-only section. */
2176 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2177 h
->plt
.refcount
+= 1;
2179 if (r_type
== R_386_PC32
)
2181 /* Since something like ".long foo - ." may be used
2182 as pointer, make sure that PLT is used if foo is
2183 a function defined in a shared library. */
2184 if ((sec
->flags
& SEC_CODE
) == 0)
2185 h
->pointer_equality_needed
= 1;
2186 else if (h
->type
== STT_GNU_IFUNC
2187 && bfd_link_pic (info
))
2190 name
= h
->root
.root
.string
;
2192 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2195 /* xgettext:c-format */
2196 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2198 bfd_set_error (bfd_error_bad_value
);
2204 h
->pointer_equality_needed
= 1;
2205 /* R_386_32 can be resolved at run-time. */
2206 if (r_type
== R_386_32
2207 && (sec
->flags
& SEC_READONLY
) == 0)
2208 eh
->func_pointer_refcount
+= 1;
2214 /* If we are creating a shared library, and this is a reloc
2215 against a global symbol, or a non PC relative reloc
2216 against a local symbol, then we need to copy the reloc
2217 into the shared library. However, if we are linking with
2218 -Bsymbolic, we do not need to copy a reloc against a
2219 global symbol which is defined in an object we are
2220 including in the link (i.e., DEF_REGULAR is set). At
2221 this point we have not seen all the input files, so it is
2222 possible that DEF_REGULAR is not set now but will be set
2223 later (it is never cleared). In case of a weak definition,
2224 DEF_REGULAR may be cleared later by a strong definition in
2225 a shared library. We account for that possibility below by
2226 storing information in the relocs_copied field of the hash
2227 table entry. A similar situation occurs when creating
2228 shared libraries and symbol visibility changes render the
2231 If on the other hand, we are creating an executable, we
2232 may need to keep relocations for symbols satisfied by a
2233 dynamic library if we manage to avoid copy relocs for the
2236 Generate dynamic pointer relocation against STT_GNU_IFUNC
2237 symbol in the non-code section. */
2238 if ((bfd_link_pic (info
)
2239 && (r_type
!= R_386_PC32
2241 && (! (bfd_link_pie (info
)
2242 || SYMBOLIC_BIND (info
, h
))
2243 || h
->root
.type
== bfd_link_hash_defweak
2244 || !h
->def_regular
))))
2246 && h
->type
== STT_GNU_IFUNC
2247 && r_type
== R_386_32
2248 && (sec
->flags
& SEC_CODE
) == 0)
2249 || (ELIMINATE_COPY_RELOCS
2250 && !bfd_link_pic (info
)
2252 && (h
->root
.type
== bfd_link_hash_defweak
2253 || !h
->def_regular
)))
2255 struct elf_dyn_relocs
*p
;
2256 struct elf_dyn_relocs
**head
;
2258 /* We must copy these reloc types into the output file.
2259 Create a reloc section in dynobj and make room for
2263 if (htab
->elf
.dynobj
== NULL
)
2264 htab
->elf
.dynobj
= abfd
;
2266 sreloc
= _bfd_elf_make_dynamic_reloc_section
2267 (sec
, htab
->elf
.dynobj
, 2, abfd
, /*rela?*/ FALSE
);
2273 /* If this is a global symbol, we count the number of
2274 relocations we need for this symbol. */
2277 head
= &eh
->dyn_relocs
;
2281 /* Track dynamic relocs needed for local syms too.
2282 We really need local syms available to do this
2287 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2292 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2296 vpp
= &elf_section_data (s
)->local_dynrel
;
2297 head
= (struct elf_dyn_relocs
**)vpp
;
2301 if (p
== NULL
|| p
->sec
!= sec
)
2303 bfd_size_type amt
= sizeof *p
;
2304 p
= (struct elf_dyn_relocs
*) bfd_alloc (htab
->elf
.dynobj
,
2316 /* Count size relocation as PC-relative relocation. */
2317 if (r_type
== R_386_PC32
|| size_reloc
)
2322 /* This relocation describes the C++ object vtable hierarchy.
2323 Reconstruct it for later use during GC. */
2324 case R_386_GNU_VTINHERIT
:
2325 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2329 /* This relocation describes which C++ vtable entries are actually
2330 used. Record for later use during GC. */
2331 case R_386_GNU_VTENTRY
:
2332 BFD_ASSERT (h
!= NULL
);
2334 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2344 && h
->plt
.refcount
> 0
2345 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2346 || h
->got
.refcount
> 0)
2347 && htab
->plt_got
== NULL
)
2349 /* Create the GOT procedure linkage table. */
2350 unsigned int plt_got_align
;
2351 const struct elf_backend_data
*bed
;
2353 bed
= get_elf_backend_data (info
->output_bfd
);
2354 BFD_ASSERT (sizeof (elf_i386_got_plt_entry
) == 8
2355 && (sizeof (elf_i386_got_plt_entry
)
2356 == sizeof (elf_i386_pic_got_plt_entry
)));
2359 if (htab
->elf
.dynobj
== NULL
)
2360 htab
->elf
.dynobj
= abfd
;
2362 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2364 (bed
->dynamic_sec_flags
2369 if (htab
->plt_got
== NULL
2370 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2376 if (r_type
== R_386_GOT32X
2377 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2378 sec
->need_convert_load
= 1;
2381 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2383 if (!info
->keep_memory
)
2387 /* Cache the section contents for elf_link_input_bfd. */
2388 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2395 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2397 sec
->check_relocs_failed
= 1;
2401 /* Return the section that should be marked against GC for a given
2405 elf_i386_gc_mark_hook (asection
*sec
,
2406 struct bfd_link_info
*info
,
2407 Elf_Internal_Rela
*rel
,
2408 struct elf_link_hash_entry
*h
,
2409 Elf_Internal_Sym
*sym
)
2412 switch (ELF32_R_TYPE (rel
->r_info
))
2414 case R_386_GNU_VTINHERIT
:
2415 case R_386_GNU_VTENTRY
:
2419 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2422 /* Remove undefined weak symbol from the dynamic symbol table if it
2423 is resolved to 0. */
2426 elf_i386_fixup_symbol (struct bfd_link_info
*info
,
2427 struct elf_link_hash_entry
*h
)
2429 if (h
->dynindx
!= -1
2430 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2431 elf_i386_hash_entry (h
)->has_got_reloc
,
2432 elf_i386_hash_entry (h
)))
2435 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2441 /* Adjust a symbol defined by a dynamic object and referenced by a
2442 regular object. The current definition is in some section of the
2443 dynamic object, but we're not including those sections. We have to
2444 change the definition to something the rest of the link can
2448 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2449 struct elf_link_hash_entry
*h
)
2451 struct elf_i386_link_hash_table
*htab
;
2453 struct elf_i386_link_hash_entry
*eh
;
2454 struct elf_dyn_relocs
*p
;
2456 /* STT_GNU_IFUNC symbol must go through PLT. */
2457 if (h
->type
== STT_GNU_IFUNC
)
2459 /* All local STT_GNU_IFUNC references must be treate as local
2460 calls via local PLT. */
2462 && SYMBOL_CALLS_LOCAL (info
, h
))
2464 bfd_size_type pc_count
= 0, count
= 0;
2465 struct elf_dyn_relocs
**pp
;
2467 eh
= (struct elf_i386_link_hash_entry
*) h
;
2468 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2470 pc_count
+= p
->pc_count
;
2471 p
->count
-= p
->pc_count
;
2480 if (pc_count
|| count
)
2485 /* Increment PLT reference count only for PC-relative
2488 if (h
->plt
.refcount
<= 0)
2489 h
->plt
.refcount
= 1;
2491 h
->plt
.refcount
+= 1;
2496 if (h
->plt
.refcount
<= 0)
2498 h
->plt
.offset
= (bfd_vma
) -1;
2504 /* If this is a function, put it in the procedure linkage table. We
2505 will fill in the contents of the procedure linkage table later,
2506 when we know the address of the .got section. */
2507 if (h
->type
== STT_FUNC
2510 if (h
->plt
.refcount
<= 0
2511 || SYMBOL_CALLS_LOCAL (info
, h
)
2512 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2513 && h
->root
.type
== bfd_link_hash_undefweak
))
2515 /* This case can occur if we saw a PLT32 reloc in an input
2516 file, but the symbol was never referred to by a dynamic
2517 object, or if all references were garbage collected. In
2518 such a case, we don't actually need to build a procedure
2519 linkage table, and we can just do a PC32 reloc instead. */
2520 h
->plt
.offset
= (bfd_vma
) -1;
2527 /* It's possible that we incorrectly decided a .plt reloc was
2528 needed for an R_386_PC32 reloc to a non-function sym in
2529 check_relocs. We can't decide accurately between function and
2530 non-function syms in check-relocs; Objects loaded later in
2531 the link may change h->type. So fix it now. */
2532 h
->plt
.offset
= (bfd_vma
) -1;
2534 /* If this is a weak symbol, and there is a real definition, the
2535 processor independent code will have arranged for us to see the
2536 real definition first, and we can just use the same value. */
2537 if (h
->u
.weakdef
!= NULL
)
2539 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2540 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2541 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2542 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2543 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2544 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2548 /* This is a reference to a symbol defined by a dynamic object which
2549 is not a function. */
2551 /* If we are creating a shared library, we must presume that the
2552 only references to the symbol are via the global offset table.
2553 For such cases we need not do anything here; the relocations will
2554 be handled correctly by relocate_section. */
2555 if (!bfd_link_executable (info
))
2558 /* If there are no references to this symbol that do not use the
2559 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2561 eh
= (struct elf_i386_link_hash_entry
*) h
;
2562 if (!h
->non_got_ref
&& !eh
->gotoff_ref
)
2565 /* If -z nocopyreloc was given, we won't generate them either. */
2566 if (info
->nocopyreloc
)
2572 htab
= elf_i386_hash_table (info
);
2576 /* If there aren't any dynamic relocs in read-only sections nor
2577 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2578 avoid the copy reloc. This doesn't work on VxWorks, where we can
2579 not have dynamic relocations (other than copy and jump slot
2580 relocations) in an executable. */
2581 if (ELIMINATE_COPY_RELOCS
2583 && !get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2585 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2587 s
= p
->sec
->output_section
;
2588 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2599 /* We must allocate the symbol in our .dynbss section, which will
2600 become part of the .bss section of the executable. There will be
2601 an entry for this symbol in the .dynsym section. The dynamic
2602 object will contain position independent code, so all references
2603 from the dynamic object to this symbol will go through the global
2604 offset table. The dynamic linker will use the .dynsym entry to
2605 determine the address it must put in the global offset table, so
2606 both the dynamic object and the regular object will refer to the
2607 same memory location for the variable. */
2609 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2610 copy the initial value out of the dynamic object and into the
2611 runtime process image. */
2612 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2614 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
2620 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2623 /* Allocate space in .plt, .got and associated reloc sections for
2627 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
2629 struct bfd_link_info
*info
;
2630 struct elf_i386_link_hash_table
*htab
;
2631 struct elf_i386_link_hash_entry
*eh
;
2632 struct elf_dyn_relocs
*p
;
2633 unsigned plt_entry_size
;
2634 bfd_boolean resolved_to_zero
;
2636 if (h
->root
.type
== bfd_link_hash_indirect
)
2639 eh
= (struct elf_i386_link_hash_entry
*) h
;
2641 info
= (struct bfd_link_info
*) inf
;
2642 htab
= elf_i386_hash_table (info
);
2646 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2648 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2652 /* Clear the reference count of function pointer relocations if
2653 symbol isn't a normal function. */
2654 if (h
->type
!= STT_FUNC
)
2655 eh
->func_pointer_refcount
= 0;
2657 /* We can't use the GOT PLT if pointer equality is needed since
2658 finish_dynamic_symbol won't clear symbol value and the dynamic
2659 linker won't update the GOT slot. We will get into an infinite
2660 loop at run-time. */
2661 if (htab
->plt_got
!= NULL
2662 && h
->type
!= STT_GNU_IFUNC
2663 && !h
->pointer_equality_needed
2664 && h
->plt
.refcount
> 0
2665 && h
->got
.refcount
> 0)
2667 /* Don't use the regular PLT if there are both GOT and GOTPLT
2669 h
->plt
.offset
= (bfd_vma
) -1;
2671 /* Use the GOT PLT. */
2672 eh
->plt_got
.refcount
= 1;
2675 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2676 here if it is defined and referenced in a non-shared object. */
2677 if (h
->type
== STT_GNU_IFUNC
2679 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
, &eh
->dyn_relocs
,
2680 &htab
->readonly_dynrelocs_against_ifunc
,
2682 plt_entry_size
, 4, TRUE
);
2683 /* Don't create the PLT entry if there are only function pointer
2684 relocations which can be resolved at run-time. */
2685 else if (htab
->elf
.dynamic_sections_created
2686 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2687 || eh
->plt_got
.refcount
> 0))
2689 bfd_boolean use_plt_got
;
2691 /* Clear the reference count of function pointer relocations
2693 eh
->func_pointer_refcount
= 0;
2695 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2697 /* Don't use the regular PLT for DF_BIND_NOW. */
2698 h
->plt
.offset
= (bfd_vma
) -1;
2700 /* Use the GOT PLT. */
2701 h
->got
.refcount
= 1;
2702 eh
->plt_got
.refcount
= 1;
2705 use_plt_got
= eh
->plt_got
.refcount
> 0;
2707 /* Make sure this symbol is output as a dynamic symbol.
2708 Undefined weak syms won't yet be marked as dynamic. */
2709 if (h
->dynindx
== -1
2711 && !resolved_to_zero
)
2713 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2717 if (bfd_link_pic (info
)
2718 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2720 asection
*s
= htab
->elf
.splt
;
2721 asection
*got_s
= htab
->plt_got
;
2723 /* If this is the first .plt entry, make room for the special
2724 first entry. The .plt section is used by prelink to undo
2725 prelinking for dynamic relocations. */
2727 s
->size
= plt_entry_size
;
2730 eh
->plt_got
.offset
= got_s
->size
;
2732 h
->plt
.offset
= s
->size
;
2734 /* If this symbol is not defined in a regular file, and we are
2735 not generating a shared library, then set the symbol to this
2736 location in the .plt. This is required to make function
2737 pointers compare as equal between the normal executable and
2738 the shared library. */
2739 if (! bfd_link_pic (info
)
2744 /* We need to make a call to the entry of the GOT PLT
2745 instead of regular PLT entry. */
2746 h
->root
.u
.def
.section
= got_s
;
2747 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2751 h
->root
.u
.def
.section
= s
;
2752 h
->root
.u
.def
.value
= h
->plt
.offset
;
2756 /* Make room for this entry. */
2758 got_s
->size
+= sizeof (elf_i386_got_plt_entry
);
2761 s
->size
+= plt_entry_size
;
2763 /* We also need to make an entry in the .got.plt section,
2764 which will be placed in the .got section by the linker
2766 htab
->elf
.sgotplt
->size
+= 4;
2768 /* There should be no PLT relocation against resolved
2769 undefined weak symbol in executable. */
2770 if (!resolved_to_zero
)
2772 /* We also need to make an entry in the .rel.plt
2774 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2775 htab
->elf
.srelplt
->reloc_count
++;
2779 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
2780 && !bfd_link_pic (info
))
2782 /* VxWorks has a second set of relocations for each PLT entry
2783 in executables. They go in a separate relocation section,
2784 which is processed by the kernel loader. */
2786 /* There are two relocations for the initial PLT entry: an
2787 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2788 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2790 if (h
->plt
.offset
== plt_entry_size
)
2791 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2793 /* There are two extra relocations for each subsequent PLT entry:
2794 an R_386_32 relocation for the GOT entry, and an R_386_32
2795 relocation for the PLT entry. */
2797 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
2802 eh
->plt_got
.offset
= (bfd_vma
) -1;
2803 h
->plt
.offset
= (bfd_vma
) -1;
2809 eh
->plt_got
.offset
= (bfd_vma
) -1;
2810 h
->plt
.offset
= (bfd_vma
) -1;
2814 eh
->tlsdesc_got
= (bfd_vma
) -1;
2816 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2817 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2818 if (h
->got
.refcount
> 0
2819 && bfd_link_executable (info
)
2821 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
2822 h
->got
.offset
= (bfd_vma
) -1;
2823 else if (h
->got
.refcount
> 0)
2827 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2829 /* Make sure this symbol is output as a dynamic symbol.
2830 Undefined weak syms won't yet be marked as dynamic. */
2831 if (h
->dynindx
== -1
2833 && !resolved_to_zero
)
2835 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2840 if (GOT_TLS_GDESC_P (tls_type
))
2842 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2843 - elf_i386_compute_jump_table_size (htab
);
2844 htab
->elf
.sgotplt
->size
+= 8;
2845 h
->got
.offset
= (bfd_vma
) -2;
2847 if (! GOT_TLS_GDESC_P (tls_type
)
2848 || GOT_TLS_GD_P (tls_type
))
2850 h
->got
.offset
= s
->size
;
2852 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2853 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
2856 dyn
= htab
->elf
.dynamic_sections_created
;
2857 /* R_386_TLS_IE_32 needs one dynamic relocation,
2858 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2859 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2860 need two), R_386_TLS_GD needs one if local symbol and two if
2861 global. No dynamic relocation against resolved undefined weak
2862 symbol in executable. */
2863 if (tls_type
== GOT_TLS_IE_BOTH
)
2864 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2865 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2866 || (tls_type
& GOT_TLS_IE
))
2867 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2868 else if (GOT_TLS_GD_P (tls_type
))
2869 htab
->elf
.srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
2870 else if (! GOT_TLS_GDESC_P (tls_type
)
2871 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2872 && !resolved_to_zero
)
2873 || h
->root
.type
!= bfd_link_hash_undefweak
)
2874 && (bfd_link_pic (info
)
2875 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2876 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
2877 if (GOT_TLS_GDESC_P (tls_type
))
2878 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
2881 h
->got
.offset
= (bfd_vma
) -1;
2883 if (eh
->dyn_relocs
== NULL
)
2886 /* In the shared -Bsymbolic case, discard space allocated for
2887 dynamic pc-relative relocs against symbols which turn out to be
2888 defined in regular objects. For the normal shared case, discard
2889 space for pc-relative relocs that have become local due to symbol
2890 visibility changes. */
2892 if (bfd_link_pic (info
))
2894 /* The only reloc that uses pc_count is R_386_PC32, which will
2895 appear on a call or on something like ".long foo - .". We
2896 want calls to protected symbols to resolve directly to the
2897 function rather than going via the plt. If people want
2898 function pointer comparisons to work as expected then they
2899 should avoid writing assembly like ".long foo - .". */
2900 if (SYMBOL_CALLS_LOCAL (info
, h
))
2902 struct elf_dyn_relocs
**pp
;
2904 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2906 p
->count
-= p
->pc_count
;
2915 if (get_elf_i386_backend_data (info
->output_bfd
)->is_vxworks
)
2917 struct elf_dyn_relocs
**pp
;
2918 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2920 if (strcmp (p
->sec
->output_section
->name
, ".tls_vars") == 0)
2927 /* Also discard relocs on undefined weak syms with non-default
2928 visibility or in PIE. */
2929 if (eh
->dyn_relocs
!= NULL
2930 && h
->root
.type
== bfd_link_hash_undefweak
)
2932 /* Undefined weak symbol is never bound locally in shared
2934 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2935 || resolved_to_zero
)
2939 /* Keep dynamic non-GOT/non-PLT relocation so that we
2940 can branch to 0 without PLT. */
2941 struct elf_dyn_relocs
**pp
;
2943 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2944 if (p
->pc_count
== 0)
2948 /* Remove non-R_386_PC32 relocation. */
2949 p
->count
= p
->pc_count
;
2953 if (eh
->dyn_relocs
!= NULL
)
2955 /* Make sure undefined weak symbols are output
2956 as dynamic symbols in PIEs for dynamic non-GOT
2957 non-PLT reloations. */
2958 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2963 eh
->dyn_relocs
= NULL
;
2965 else if (h
->dynindx
== -1
2966 && !h
->forced_local
)
2968 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2973 else if (ELIMINATE_COPY_RELOCS
)
2975 /* For the non-shared case, discard space for relocs against
2976 symbols which turn out to need copy relocs or are not
2977 dynamic. Keep dynamic relocations for run-time function
2978 pointer initialization. */
2980 if ((!h
->non_got_ref
2981 || eh
->func_pointer_refcount
> 0
2982 || (h
->root
.type
== bfd_link_hash_undefweak
2983 && !resolved_to_zero
))
2986 || (htab
->elf
.dynamic_sections_created
2987 && (h
->root
.type
== bfd_link_hash_undefweak
2988 || h
->root
.type
== bfd_link_hash_undefined
))))
2990 /* Make sure this symbol is output as a dynamic symbol.
2991 Undefined weak syms won't yet be marked as dynamic. */
2992 if (h
->dynindx
== -1
2994 && !resolved_to_zero
)
2996 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3000 /* If that succeeded, we know we'll be keeping all the
3002 if (h
->dynindx
!= -1)
3006 eh
->dyn_relocs
= NULL
;
3007 eh
->func_pointer_refcount
= 0;
3012 /* Finally, allocate space. */
3013 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3017 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3019 BFD_ASSERT (sreloc
!= NULL
);
3020 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3026 /* Allocate space in .plt, .got and associated reloc sections for
3027 local dynamic relocs. */
3030 elf_i386_allocate_local_dynrelocs (void **slot
, void *inf
)
3032 struct elf_link_hash_entry
*h
3033 = (struct elf_link_hash_entry
*) *slot
;
3035 if (h
->type
!= STT_GNU_IFUNC
3039 || h
->root
.type
!= bfd_link_hash_defined
)
3042 return elf_i386_allocate_dynrelocs (h
, inf
);
3045 /* Find any dynamic relocs that apply to read-only sections. */
3048 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
3050 struct elf_i386_link_hash_entry
*eh
;
3051 struct elf_dyn_relocs
*p
;
3053 /* Skip local IFUNC symbols. */
3054 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3057 eh
= (struct elf_i386_link_hash_entry
*) h
;
3058 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3060 asection
*s
= p
->sec
->output_section
;
3062 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3064 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3066 info
->flags
|= DF_TEXTREL
;
3068 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3069 || info
->error_textrel
)
3070 /* xgettext:c-format */
3071 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3072 p
->sec
->owner
, h
->root
.root
.string
,
3075 /* Not an error, just cut short the traversal. */
3082 /* Convert load via the GOT slot to load immediate. */
3085 elf_i386_convert_load (bfd
*abfd
, asection
*sec
,
3086 struct bfd_link_info
*link_info
)
3088 struct elf_i386_link_hash_table
*htab
;
3089 Elf_Internal_Shdr
*symtab_hdr
;
3090 Elf_Internal_Rela
*internal_relocs
;
3091 Elf_Internal_Rela
*irel
, *irelend
;
3093 bfd_boolean changed
;
3094 bfd_signed_vma
*local_got_refcounts
;
3096 /* Don't even try to convert non-ELF outputs. */
3097 if (!is_elf_hash_table (link_info
->hash
))
3100 /* Nothing to do if there is no need or no output. */
3101 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3102 || sec
->need_convert_load
== 0
3103 || bfd_is_abs_section (sec
->output_section
))
3106 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3108 /* Load the relocations for this section. */
3109 internal_relocs
= (_bfd_elf_link_read_relocs
3110 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3111 link_info
->keep_memory
));
3112 if (internal_relocs
== NULL
)
3116 htab
= elf_i386_hash_table (link_info
);
3117 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3119 /* Get the section contents. */
3120 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3121 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3124 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3128 irelend
= internal_relocs
+ sec
->reloc_count
;
3129 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3131 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3132 unsigned int r_symndx
;
3133 struct elf_link_hash_entry
*h
;
3134 bfd_boolean converted
;
3136 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3137 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3138 if (r_type
!= R_386_GOT32X
)
3141 r_symndx
= ELF32_R_SYM (irel
->r_info
);
3142 if (r_symndx
< symtab_hdr
->sh_info
)
3143 h
= elf_i386_get_local_sym_hash (htab
, sec
->owner
,
3144 (const Elf_Internal_Rela
*) irel
,
3148 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3149 while (h
->root
.type
== bfd_link_hash_indirect
3150 || h
->root
.type
== bfd_link_hash_warning
)
3151 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3154 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3155 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3159 if (!elf_i386_convert_load_reloc (abfd
, symtab_hdr
, contents
,
3160 irel
, h
, &converted
, link_info
))
3165 changed
= converted
;
3168 if (h
->got
.refcount
> 0)
3169 h
->got
.refcount
-= 1;
3173 if (local_got_refcounts
!= NULL
3174 && local_got_refcounts
[r_symndx
] > 0)
3175 local_got_refcounts
[r_symndx
] -= 1;
3180 if (contents
!= NULL
3181 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3183 if (!changed
&& !link_info
->keep_memory
)
3187 /* Cache the section contents for elf_link_input_bfd. */
3188 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3192 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3195 free (internal_relocs
);
3197 elf_section_data (sec
)->relocs
= internal_relocs
;
3203 if (contents
!= NULL
3204 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3206 if (internal_relocs
!= NULL
3207 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3208 free (internal_relocs
);
3212 /* Set the sizes of the dynamic sections. */
3215 elf_i386_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3217 struct elf_i386_link_hash_table
*htab
;
3223 htab
= elf_i386_hash_table (info
);
3226 dynobj
= htab
->elf
.dynobj
;
3230 /* Set up .got offsets for local syms, and space for local dynamic
3232 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3234 bfd_signed_vma
*local_got
;
3235 bfd_signed_vma
*end_local_got
;
3236 char *local_tls_type
;
3237 bfd_vma
*local_tlsdesc_gotent
;
3238 bfd_size_type locsymcount
;
3239 Elf_Internal_Shdr
*symtab_hdr
;
3242 if (! is_i386_elf (ibfd
))
3245 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3247 struct elf_dyn_relocs
*p
;
3249 if (!elf_i386_convert_load (ibfd
, s
, info
))
3252 for (p
= ((struct elf_dyn_relocs
*)
3253 elf_section_data (s
)->local_dynrel
);
3257 if (!bfd_is_abs_section (p
->sec
)
3258 && bfd_is_abs_section (p
->sec
->output_section
))
3260 /* Input section has been discarded, either because
3261 it is a copy of a linkonce section or due to
3262 linker script /DISCARD/, so we'll be discarding
3265 else if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3266 && strcmp (p
->sec
->output_section
->name
,
3269 /* Relocations in vxworks .tls_vars sections are
3270 handled specially by the loader. */
3272 else if (p
->count
!= 0)
3274 srel
= elf_section_data (p
->sec
)->sreloc
;
3275 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3276 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3277 && (info
->flags
& DF_TEXTREL
) == 0)
3279 info
->flags
|= DF_TEXTREL
;
3280 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3281 || info
->error_textrel
)
3282 /* xgettext:c-format */
3283 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3284 p
->sec
->owner
, p
->sec
);
3290 local_got
= elf_local_got_refcounts (ibfd
);
3294 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3295 locsymcount
= symtab_hdr
->sh_info
;
3296 end_local_got
= local_got
+ locsymcount
;
3297 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
3298 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
3300 srel
= htab
->elf
.srelgot
;
3301 for (; local_got
< end_local_got
;
3302 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3304 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3307 if (GOT_TLS_GDESC_P (*local_tls_type
))
3309 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3310 - elf_i386_compute_jump_table_size (htab
);
3311 htab
->elf
.sgotplt
->size
+= 8;
3312 *local_got
= (bfd_vma
) -2;
3314 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3315 || GOT_TLS_GD_P (*local_tls_type
))
3317 *local_got
= s
->size
;
3319 if (GOT_TLS_GD_P (*local_tls_type
)
3320 || *local_tls_type
== GOT_TLS_IE_BOTH
)
3323 if (bfd_link_pic (info
)
3324 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3325 || (*local_tls_type
& GOT_TLS_IE
))
3327 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
3328 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
3329 else if (GOT_TLS_GD_P (*local_tls_type
)
3330 || ! GOT_TLS_GDESC_P (*local_tls_type
))
3331 srel
->size
+= sizeof (Elf32_External_Rel
);
3332 if (GOT_TLS_GDESC_P (*local_tls_type
))
3333 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rel
);
3337 *local_got
= (bfd_vma
) -1;
3341 if (htab
->tls_ldm_got
.refcount
> 0)
3343 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3345 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
3346 htab
->elf
.sgot
->size
+= 8;
3347 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rel
);
3350 htab
->tls_ldm_got
.offset
= -1;
3352 /* Allocate global sym .plt and .got entries, and space for global
3353 sym dynamic relocs. */
3354 elf_link_hash_traverse (&htab
->elf
, elf_i386_allocate_dynrelocs
, info
);
3356 /* Allocate .plt and .got entries, and space for local symbols. */
3357 htab_traverse (htab
->loc_hash_table
,
3358 elf_i386_allocate_local_dynrelocs
,
3361 /* For every jump slot reserved in the sgotplt, reloc_count is
3362 incremented. However, when we reserve space for TLS descriptors,
3363 it's not incremented, so in order to compute the space reserved
3364 for them, it suffices to multiply the reloc count by the jump
3367 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3368 so that R_386_IRELATIVE entries come last. */
3369 if (htab
->elf
.srelplt
)
3371 htab
->next_tls_desc_index
= htab
->elf
.srelplt
->reloc_count
;
3372 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
3373 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3375 else if (htab
->elf
.irelplt
)
3376 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3379 if (htab
->elf
.sgotplt
)
3381 /* Don't allocate .got.plt section if there are no GOT nor PLT
3382 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3383 if ((htab
->elf
.hgot
== NULL
3384 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3385 && (htab
->elf
.sgotplt
->size
3386 == get_elf_backend_data (output_bfd
)->got_header_size
)
3387 && (htab
->elf
.splt
== NULL
3388 || htab
->elf
.splt
->size
== 0)
3389 && (htab
->elf
.sgot
== NULL
3390 || htab
->elf
.sgot
->size
== 0)
3391 && (htab
->elf
.iplt
== NULL
3392 || htab
->elf
.iplt
->size
== 0)
3393 && (htab
->elf
.igotplt
== NULL
3394 || htab
->elf
.igotplt
->size
== 0))
3395 htab
->elf
.sgotplt
->size
= 0;
3399 if (htab
->plt_eh_frame
!= NULL
3400 && htab
->elf
.splt
!= NULL
3401 && htab
->elf
.splt
->size
!= 0
3402 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3403 && _bfd_elf_eh_frame_present (info
))
3404 htab
->plt_eh_frame
->size
= sizeof (elf_i386_eh_frame_plt
);
3406 /* We now have determined the sizes of the various dynamic sections.
3407 Allocate memory for them. */
3409 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3411 bfd_boolean strip_section
= TRUE
;
3413 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3416 if (s
== htab
->elf
.splt
3417 || s
== htab
->elf
.sgot
)
3419 /* Strip this section if we don't need it; see the
3421 /* We'd like to strip these sections if they aren't needed, but if
3422 we've exported dynamic symbols from them we must leave them.
3423 It's too late to tell BFD to get rid of the symbols. */
3425 if (htab
->elf
.hplt
!= NULL
)
3426 strip_section
= FALSE
;
3428 else if (s
== htab
->elf
.sgotplt
3429 || s
== htab
->elf
.iplt
3430 || s
== htab
->elf
.igotplt
3431 || s
== htab
->plt_got
3432 || s
== htab
->plt_eh_frame
3433 || s
== htab
->sdynbss
)
3435 /* Strip these too. */
3437 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rel"))
3440 && s
!= htab
->elf
.srelplt
3441 && s
!= htab
->srelplt2
)
3444 /* We use the reloc_count field as a counter if we need
3445 to copy relocs into the output file. */
3450 /* It's not one of our sections, so don't allocate space. */
3456 /* If we don't need this section, strip it from the
3457 output file. This is mostly to handle .rel.bss and
3458 .rel.plt. We must create both sections in
3459 create_dynamic_sections, because they must be created
3460 before the linker maps input sections to output
3461 sections. The linker does that before
3462 adjust_dynamic_symbol is called, and it is that
3463 function which decides whether anything needs to go
3464 into these sections. */
3466 s
->flags
|= SEC_EXCLUDE
;
3470 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3473 /* Allocate memory for the section contents. We use bfd_zalloc
3474 here in case unused entries are not reclaimed before the
3475 section's contents are written out. This should not happen,
3476 but this way if it does, we get a R_386_NONE reloc instead
3478 s
->contents
= (unsigned char *) bfd_zalloc (dynobj
, s
->size
);
3479 if (s
->contents
== NULL
)
3483 if (htab
->plt_eh_frame
!= NULL
3484 && htab
->plt_eh_frame
->contents
!= NULL
)
3486 memcpy (htab
->plt_eh_frame
->contents
, elf_i386_eh_frame_plt
,
3487 sizeof (elf_i386_eh_frame_plt
));
3488 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3489 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3492 if (htab
->elf
.dynamic_sections_created
)
3494 /* Add some entries to the .dynamic section. We fill in the
3495 values later, in elf_i386_finish_dynamic_sections, but we
3496 must add the entries now so that we get the correct size for
3497 the .dynamic section. The DT_DEBUG entry is filled in by the
3498 dynamic linker and used by the debugger. */
3499 #define add_dynamic_entry(TAG, VAL) \
3500 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3502 if (bfd_link_executable (info
))
3504 if (!add_dynamic_entry (DT_DEBUG
, 0))
3508 if (htab
->elf
.splt
->size
!= 0)
3510 /* DT_PLTGOT is used by prelink even if there is no PLT
3512 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3515 if (htab
->elf
.srelplt
->size
!= 0)
3517 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3518 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3519 || !add_dynamic_entry (DT_JMPREL
, 0))
3526 if (!add_dynamic_entry (DT_REL
, 0)
3527 || !add_dynamic_entry (DT_RELSZ
, 0)
3528 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3531 /* If any dynamic relocs apply to a read-only section,
3532 then we need a DT_TEXTREL entry. */
3533 if ((info
->flags
& DF_TEXTREL
) == 0)
3534 elf_link_hash_traverse (&htab
->elf
,
3535 elf_i386_readonly_dynrelocs
, info
);
3537 if ((info
->flags
& DF_TEXTREL
) != 0)
3539 if (htab
->readonly_dynrelocs_against_ifunc
)
3541 info
->callbacks
->einfo
3542 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3543 bfd_set_error (bfd_error_bad_value
);
3547 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3551 if (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3552 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
3555 #undef add_dynamic_entry
3561 elf_i386_always_size_sections (bfd
*output_bfd
,
3562 struct bfd_link_info
*info
)
3564 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3568 struct elf_link_hash_entry
*tlsbase
;
3570 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3571 "_TLS_MODULE_BASE_",
3572 FALSE
, FALSE
, FALSE
);
3574 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3576 struct elf_i386_link_hash_table
*htab
;
3577 struct bfd_link_hash_entry
*bh
= NULL
;
3578 const struct elf_backend_data
*bed
3579 = get_elf_backend_data (output_bfd
);
3581 htab
= elf_i386_hash_table (info
);
3585 if (!(_bfd_generic_link_add_one_symbol
3586 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3587 tls_sec
, 0, NULL
, FALSE
,
3588 bed
->collect
, &bh
)))
3591 htab
->tls_module_base
= bh
;
3593 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3594 tlsbase
->def_regular
= 1;
3595 tlsbase
->other
= STV_HIDDEN
;
3596 tlsbase
->root
.linker_def
= 1;
3597 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3604 /* Set the correct type for an x86 ELF section. We do this by the
3605 section name, which is a hack, but ought to work. */
3608 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3609 Elf_Internal_Shdr
*hdr
,
3614 name
= bfd_get_section_name (abfd
, sec
);
3616 /* This is an ugly, but unfortunately necessary hack that is
3617 needed when producing EFI binaries on x86. It tells
3618 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3619 containing ELF relocation info. We need this hack in order to
3620 be able to generate ELF binaries that can be translated into
3621 EFI applications (which are essentially COFF objects). Those
3622 files contain a COFF ".reloc" section inside an ELFNN object,
3623 which would normally cause BFD to segfault because it would
3624 attempt to interpret this section as containing relocation
3625 entries for section "oc". With this hack enabled, ".reloc"
3626 will be treated as a normal data section, which will avoid the
3627 segfault. However, you won't be able to create an ELFNN binary
3628 with a section named "oc" that needs relocations, but that's
3629 the kind of ugly side-effects you get when detecting section
3630 types based on their names... In practice, this limitation is
3631 unlikely to bite. */
3632 if (strcmp (name
, ".reloc") == 0)
3633 hdr
->sh_type
= SHT_PROGBITS
;
3638 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3639 executables. Rather than setting it to the beginning of the TLS
3640 section, we have to set it to the end. This function may be called
3641 multiple times, it is idempotent. */
3644 elf_i386_set_tls_module_base (struct bfd_link_info
*info
)
3646 struct elf_i386_link_hash_table
*htab
;
3647 struct bfd_link_hash_entry
*base
;
3649 if (!bfd_link_executable (info
))
3652 htab
= elf_i386_hash_table (info
);
3656 base
= htab
->tls_module_base
;
3660 base
->u
.def
.value
= htab
->elf
.tls_size
;
3663 /* Return the base VMA address which should be subtracted from real addresses
3664 when resolving @dtpoff relocation.
3665 This is PT_TLS segment p_vaddr. */
3668 elf_i386_dtpoff_base (struct bfd_link_info
*info
)
3670 /* If tls_sec is NULL, we should have signalled an error already. */
3671 if (elf_hash_table (info
)->tls_sec
== NULL
)
3673 return elf_hash_table (info
)->tls_sec
->vma
;
3676 /* Return the relocation value for @tpoff relocation
3677 if STT_TLS virtual address is ADDRESS. */
3680 elf_i386_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3682 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3683 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3684 bfd_vma static_tls_size
;
3686 /* If tls_sec is NULL, we should have signalled an error already. */
3687 if (htab
->tls_sec
== NULL
)
3690 /* Consider special static TLS alignment requirements. */
3691 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3692 return static_tls_size
+ htab
->tls_sec
->vma
- address
;
3695 /* Relocate an i386 ELF section. */
3698 elf_i386_relocate_section (bfd
*output_bfd
,
3699 struct bfd_link_info
*info
,
3701 asection
*input_section
,
3703 Elf_Internal_Rela
*relocs
,
3704 Elf_Internal_Sym
*local_syms
,
3705 asection
**local_sections
)
3707 struct elf_i386_link_hash_table
*htab
;
3708 Elf_Internal_Shdr
*symtab_hdr
;
3709 struct elf_link_hash_entry
**sym_hashes
;
3710 bfd_vma
*local_got_offsets
;
3711 bfd_vma
*local_tlsdesc_gotents
;
3712 Elf_Internal_Rela
*rel
;
3713 Elf_Internal_Rela
*wrel
;
3714 Elf_Internal_Rela
*relend
;
3715 bfd_boolean is_vxworks_tls
;
3716 unsigned plt_entry_size
;
3718 BFD_ASSERT (is_i386_elf (input_bfd
));
3720 /* Skip if check_relocs failed. */
3721 if (input_section
->check_relocs_failed
)
3724 htab
= elf_i386_hash_table (info
);
3727 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3728 sym_hashes
= elf_sym_hashes (input_bfd
);
3729 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3730 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
3731 /* We have to handle relocations in vxworks .tls_vars sections
3732 specially, because the dynamic loader is 'weird'. */
3733 is_vxworks_tls
= (get_elf_i386_backend_data (output_bfd
)->is_vxworks
3734 && bfd_link_pic (info
)
3735 && !strcmp (input_section
->output_section
->name
,
3738 elf_i386_set_tls_module_base (info
);
3740 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
3742 rel
= wrel
= relocs
;
3743 relend
= relocs
+ input_section
->reloc_count
;
3744 for (; rel
< relend
; wrel
++, rel
++)
3746 unsigned int r_type
;
3747 reloc_howto_type
*howto
;
3748 unsigned long r_symndx
;
3749 struct elf_link_hash_entry
*h
;
3750 struct elf_i386_link_hash_entry
*eh
;
3751 Elf_Internal_Sym
*sym
;
3753 bfd_vma off
, offplt
, plt_offset
;
3755 bfd_boolean unresolved_reloc
;
3756 bfd_reloc_status_type r
;
3760 asection
*resolved_plt
;
3761 bfd_boolean resolved_to_zero
;
3763 r_type
= ELF32_R_TYPE (rel
->r_info
);
3764 if (r_type
== R_386_GNU_VTINHERIT
3765 || r_type
== R_386_GNU_VTENTRY
)
3772 if ((indx
= r_type
) >= R_386_standard
3773 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
3774 >= R_386_ext
- R_386_standard
)
3775 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
3776 >= R_386_ext2
- R_386_ext
))
3779 /* xgettext:c-format */
3780 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3781 input_bfd
, input_section
, r_type
);
3782 bfd_set_error (bfd_error_bad_value
);
3785 howto
= elf_howto_table
+ indx
;
3787 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3791 unresolved_reloc
= FALSE
;
3792 if (r_symndx
< symtab_hdr
->sh_info
)
3794 sym
= local_syms
+ r_symndx
;
3795 sec
= local_sections
[r_symndx
];
3796 relocation
= (sec
->output_section
->vma
3797 + sec
->output_offset
3799 st_size
= sym
->st_size
;
3801 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3802 && ((sec
->flags
& SEC_MERGE
) != 0
3803 || (bfd_link_relocatable (info
)
3804 && sec
->output_offset
!= 0)))
3807 bfd_byte
*where
= contents
+ rel
->r_offset
;
3809 switch (howto
->size
)
3812 addend
= bfd_get_8 (input_bfd
, where
);
3813 if (howto
->pc_relative
)
3815 addend
= (addend
^ 0x80) - 0x80;
3820 addend
= bfd_get_16 (input_bfd
, where
);
3821 if (howto
->pc_relative
)
3823 addend
= (addend
^ 0x8000) - 0x8000;
3828 addend
= bfd_get_32 (input_bfd
, where
);
3829 if (howto
->pc_relative
)
3831 addend
= (addend
^ 0x80000000) - 0x80000000;
3839 if (bfd_link_relocatable (info
))
3840 addend
+= sec
->output_offset
;
3843 asection
*msec
= sec
;
3844 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
,
3846 addend
-= relocation
;
3847 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
3850 switch (howto
->size
)
3853 /* FIXME: overflow checks. */
3854 if (howto
->pc_relative
)
3856 bfd_put_8 (input_bfd
, addend
, where
);
3859 if (howto
->pc_relative
)
3861 bfd_put_16 (input_bfd
, addend
, where
);
3864 if (howto
->pc_relative
)
3866 bfd_put_32 (input_bfd
, addend
, where
);
3870 else if (!bfd_link_relocatable (info
)
3871 && ELF32_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3873 /* Relocate against local STT_GNU_IFUNC symbol. */
3874 h
= elf_i386_get_local_sym_hash (htab
, input_bfd
, rel
,
3879 /* Set STT_GNU_IFUNC symbol value. */
3880 h
->root
.u
.def
.value
= sym
->st_value
;
3881 h
->root
.u
.def
.section
= sec
;
3886 bfd_boolean warned ATTRIBUTE_UNUSED
;
3887 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3889 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3890 r_symndx
, symtab_hdr
, sym_hashes
,
3892 unresolved_reloc
, warned
, ignored
);
3896 if (sec
!= NULL
&& discarded_section (sec
))
3898 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3899 contents
+ rel
->r_offset
);
3900 wrel
->r_offset
= rel
->r_offset
;
3904 /* For ld -r, remove relocations in debug sections against
3905 sections defined in discarded sections. Not done for
3906 eh_frame editing code expects to be present. */
3907 if (bfd_link_relocatable (info
)
3908 && (input_section
->flags
& SEC_DEBUGGING
))
3914 if (bfd_link_relocatable (info
))
3921 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3922 it here if it is defined in a non-shared object. */
3924 && h
->type
== STT_GNU_IFUNC
3927 asection
*plt
, *gotplt
, *base_got
;
3931 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3933 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3934 sections because such sections are not SEC_ALLOC and
3935 thus ld.so will not process them. */
3936 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3941 /* STT_GNU_IFUNC symbol must go through PLT. */
3942 if (htab
->elf
.splt
!= NULL
)
3944 plt
= htab
->elf
.splt
;
3945 gotplt
= htab
->elf
.sgotplt
;
3949 plt
= htab
->elf
.iplt
;
3950 gotplt
= htab
->elf
.igotplt
;
3960 base_got
= htab
->elf
.sgot
;
3961 off
= h
->got
.offset
;
3963 if (base_got
== NULL
)
3966 if (off
== (bfd_vma
) -1)
3968 /* We can't use h->got.offset here to save state, or
3969 even just remember the offset, as finish_dynamic_symbol
3970 would use that as offset into .got. */
3972 if (h
->plt
.offset
== (bfd_vma
) -1)
3975 if (htab
->elf
.splt
!= NULL
)
3977 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3978 off
= (plt_index
+ 3) * 4;
3979 base_got
= htab
->elf
.sgotplt
;
3983 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3984 off
= plt_index
* 4;
3985 base_got
= htab
->elf
.igotplt
;
3988 if (h
->dynindx
== -1
3992 /* This references the local defitionion. We must
3993 initialize this entry in the global offset table.
3994 Since the offset must always be a multiple of 8,
3995 we use the least significant bit to record
3996 whether we have initialized it already.
3998 When doing a dynamic link, we create a .rela.got
3999 relocation entry to initialize the value. This
4000 is done in the finish_dynamic_symbol routine. */
4005 bfd_put_32 (output_bfd
, relocation
,
4006 base_got
->contents
+ off
);
4014 relocation
= (base_got
->output_section
->vma
4015 + base_got
->output_offset
+ off
4016 - gotplt
->output_section
->vma
4017 - gotplt
->output_offset
);
4019 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4021 if (bfd_link_pic (info
))
4022 goto disallow_got32
;
4024 /* Add the GOT base if there is no base register. */
4025 relocation
+= (gotplt
->output_section
->vma
4026 + gotplt
->output_offset
);
4028 else if (htab
->elf
.splt
== NULL
)
4030 /* Adjust for static executables. */
4031 relocation
+= gotplt
->output_offset
;
4037 if (h
->plt
.offset
== (bfd_vma
) -1)
4039 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4040 if (r_type
== R_386_32
4041 && (input_section
->flags
& SEC_CODE
) == 0)
4042 goto do_ifunc_pointer
;
4043 goto bad_ifunc_reloc
;
4046 relocation
= (plt
->output_section
->vma
4047 + plt
->output_offset
+ h
->plt
.offset
);
4053 if (h
->root
.root
.string
)
4054 name
= h
->root
.root
.string
;
4056 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4059 /* xgettext:c-format */
4060 (_("%B: relocation %s against STT_GNU_IFUNC "
4061 "symbol `%s' isn't supported"), input_bfd
,
4063 bfd_set_error (bfd_error_bad_value
);
4067 /* Generate dynamic relcoation only when there is a
4068 non-GOT reference in a shared object. */
4069 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4070 || h
->plt
.offset
== (bfd_vma
) -1)
4072 Elf_Internal_Rela outrel
;
4077 /* Need a dynamic relocation to get the real function
4079 offset
= _bfd_elf_section_offset (output_bfd
,
4083 if (offset
== (bfd_vma
) -1
4084 || offset
== (bfd_vma
) -2)
4087 outrel
.r_offset
= (input_section
->output_section
->vma
4088 + input_section
->output_offset
4091 if (h
->dynindx
== -1
4093 || bfd_link_executable (info
))
4095 /* This symbol is resolved locally. */
4096 outrel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
4097 bfd_put_32 (output_bfd
,
4098 (h
->root
.u
.def
.value
4099 + h
->root
.u
.def
.section
->output_section
->vma
4100 + h
->root
.u
.def
.section
->output_offset
),
4104 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4106 /* Dynamic relocations are stored in
4107 1. .rel.ifunc section in PIC object.
4108 2. .rel.got section in dynamic executable.
4109 3. .rel.iplt section in static executable. */
4110 if (bfd_link_pic (info
))
4111 sreloc
= htab
->elf
.irelifunc
;
4112 else if (htab
->elf
.splt
!= NULL
)
4113 sreloc
= htab
->elf
.srelgot
;
4115 sreloc
= htab
->elf
.irelplt
;
4116 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4118 /* If this reloc is against an external symbol, we
4119 do not want to fiddle with the addend. Otherwise,
4120 we need to include the symbol value so that it
4121 becomes an addend for the dynamic reloc. For an
4122 internal symbol, we have updated addend. */
4131 relocation
-= (gotplt
->output_section
->vma
4132 + gotplt
->output_offset
);
4137 eh
= (struct elf_i386_link_hash_entry
*) h
;
4138 resolved_to_zero
= (eh
!= NULL
4139 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4146 /* Avoid optimizing _DYNAMIC since ld.so may use its
4147 link-time address. */
4148 if (h
== htab
->elf
.hdynamic
)
4151 if (bfd_link_pic (info
))
4153 /* It is OK to convert mov to lea and convert indirect
4154 branch to direct branch. It is OK to convert adc,
4155 add, and, cmp, or, sbb, sub, test, xor only when PIC
4157 unsigned int opcode
, addend
;
4158 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4161 opcode
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4162 if (opcode
!= 0x8b && opcode
!= 0xff)
4166 /* Resolve "mov GOT[(%reg)], %reg",
4167 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4168 and "binop foo@GOT[(%reg)], %reg". */
4170 || (h
->plt
.offset
== (bfd_vma
) -1
4171 && h
->got
.offset
== (bfd_vma
) -1)
4172 || htab
->elf
.sgotplt
== NULL
)
4175 offplt
= (htab
->elf
.sgotplt
->output_section
->vma
4176 + htab
->elf
.sgotplt
->output_offset
);
4178 /* It is relative to .got.plt section. */
4179 if (h
->got
.offset
!= (bfd_vma
) -1)
4180 /* Use GOT entry. Mask off the least significant bit in
4181 GOT offset which may be set by R_386_GOT32 processing
4183 relocation
= (htab
->elf
.sgot
->output_section
->vma
4184 + htab
->elf
.sgot
->output_offset
4185 + (h
->got
.offset
& ~1) - offplt
);
4187 /* Use GOTPLT entry. */
4188 relocation
= (h
->plt
.offset
/ plt_entry_size
- 1 + 3) * 4;
4190 if (!bfd_link_pic (info
))
4192 /* If not PIC, add the .got.plt section address for
4193 baseless addressing. */
4195 modrm
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4196 if ((modrm
& 0xc7) == 0x5)
4197 relocation
+= offplt
;
4200 unresolved_reloc
= FALSE
;
4205 /* Relocation is to the entry for this symbol in the global
4207 if (htab
->elf
.sgot
== NULL
)
4214 off
= h
->got
.offset
;
4215 dyn
= htab
->elf
.dynamic_sections_created
;
4216 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4217 bfd_link_pic (info
),
4219 || (bfd_link_pic (info
)
4220 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4221 || (ELF_ST_VISIBILITY (h
->other
)
4222 && h
->root
.type
== bfd_link_hash_undefweak
))
4224 /* This is actually a static link, or it is a
4225 -Bsymbolic link and the symbol is defined
4226 locally, or the symbol was forced to be local
4227 because of a version file. We must initialize
4228 this entry in the global offset table. Since the
4229 offset must always be a multiple of 4, we use the
4230 least significant bit to record whether we have
4231 initialized it already.
4233 When doing a dynamic link, we create a .rel.got
4234 relocation entry to initialize the value. This
4235 is done in the finish_dynamic_symbol routine. */
4240 bfd_put_32 (output_bfd
, relocation
,
4241 htab
->elf
.sgot
->contents
+ off
);
4246 unresolved_reloc
= FALSE
;
4250 if (local_got_offsets
== NULL
)
4253 off
= local_got_offsets
[r_symndx
];
4255 /* The offset must always be a multiple of 4. We use
4256 the least significant bit to record whether we have
4257 already generated the necessary reloc. */
4262 bfd_put_32 (output_bfd
, relocation
,
4263 htab
->elf
.sgot
->contents
+ off
);
4265 if (bfd_link_pic (info
))
4268 Elf_Internal_Rela outrel
;
4270 s
= htab
->elf
.srelgot
;
4274 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4275 + htab
->elf
.sgot
->output_offset
4277 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4278 elf_append_rel (output_bfd
, s
, &outrel
);
4281 local_got_offsets
[r_symndx
] |= 1;
4285 if (off
>= (bfd_vma
) -2)
4288 relocation
= (htab
->elf
.sgot
->output_section
->vma
4289 + htab
->elf
.sgot
->output_offset
+ off
);
4290 if ((*(contents
+ rel
->r_offset
- 1) & 0xc7) == 0x5)
4292 if (bfd_link_pic (info
))
4294 /* For PIC, disallow R_386_GOT32 without a base
4295 register since we don't know what the GOT base
4301 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4304 name
= h
->root
.root
.string
;
4307 /* xgettext:c-format */
4308 (_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
4309 input_bfd
, howto
->name
, name
);
4310 bfd_set_error (bfd_error_bad_value
);
4316 /* Subtract the .got.plt section address only with a base
4318 relocation
-= (htab
->elf
.sgotplt
->output_section
->vma
4319 + htab
->elf
.sgotplt
->output_offset
);
4325 /* Relocation is relative to the start of the global offset
4328 /* Check to make sure it isn't a protected function or data
4329 symbol for shared library since it may not be local when
4330 used as function address or with copy relocation. We also
4331 need to make sure that a symbol is referenced locally. */
4332 if (!bfd_link_executable (info
) && h
)
4334 if (!h
->def_regular
)
4338 switch (ELF_ST_VISIBILITY (h
->other
))
4341 v
= _("hidden symbol");
4344 v
= _("internal symbol");
4347 v
= _("protected symbol");
4355 /* xgettext:c-format */
4356 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4357 input_bfd
, v
, h
->root
.root
.string
);
4358 bfd_set_error (bfd_error_bad_value
);
4361 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
4362 && (h
->type
== STT_FUNC
4363 || h
->type
== STT_OBJECT
)
4364 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4367 /* xgettext:c-format */
4368 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4370 h
->type
== STT_FUNC
? "function" : "data",
4371 h
->root
.root
.string
);
4372 bfd_set_error (bfd_error_bad_value
);
4377 /* Note that sgot is not involved in this
4378 calculation. We always want the start of .got.plt. If we
4379 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4380 permitted by the ABI, we might have to change this
4382 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4383 + htab
->elf
.sgotplt
->output_offset
;
4387 /* Use global offset table as symbol value. */
4388 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4389 + htab
->elf
.sgotplt
->output_offset
;
4390 unresolved_reloc
= FALSE
;
4394 /* Relocation is to the entry for this symbol in the
4395 procedure linkage table. */
4397 /* Resolve a PLT32 reloc against a local symbol directly,
4398 without using the procedure linkage table. */
4402 if ((h
->plt
.offset
== (bfd_vma
) -1
4403 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4404 || htab
->elf
.splt
== NULL
)
4406 /* We didn't make a PLT entry for this symbol. This
4407 happens when statically linking PIC code, or when
4408 using -Bsymbolic. */
4412 if (h
->plt
.offset
!= (bfd_vma
) -1)
4414 resolved_plt
= htab
->elf
.splt
;
4415 plt_offset
= h
->plt
.offset
;
4419 resolved_plt
= htab
->plt_got
;
4420 plt_offset
= eh
->plt_got
.offset
;
4423 relocation
= (resolved_plt
->output_section
->vma
4424 + resolved_plt
->output_offset
4426 unresolved_reloc
= FALSE
;
4430 /* Set to symbol size. */
4431 relocation
= st_size
;
4436 if ((input_section
->flags
& SEC_ALLOC
) == 0
4440 /* Copy dynamic function pointer relocations. Don't generate
4441 dynamic relocations against resolved undefined weak symbols
4442 in PIE, except for R_386_PC32. */
4443 if ((bfd_link_pic (info
)
4445 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4446 && (!resolved_to_zero
4447 || r_type
== R_386_PC32
))
4448 || h
->root
.type
!= bfd_link_hash_undefweak
))
4449 && ((r_type
!= R_386_PC32
&& r_type
!= R_386_SIZE32
)
4450 || !SYMBOL_CALLS_LOCAL (info
, h
)))
4451 || (ELIMINATE_COPY_RELOCS
4452 && !bfd_link_pic (info
)
4456 || eh
->func_pointer_refcount
> 0
4457 || (h
->root
.type
== bfd_link_hash_undefweak
4458 && !resolved_to_zero
))
4459 && ((h
->def_dynamic
&& !h
->def_regular
)
4460 /* Undefined weak symbol is bound locally when
4462 || h
->root
.type
== bfd_link_hash_undefweak
)))
4464 Elf_Internal_Rela outrel
;
4465 bfd_boolean skip
, relocate
;
4468 /* When generating a shared object, these relocations
4469 are copied into the output file to be resolved at run
4476 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4478 if (outrel
.r_offset
== (bfd_vma
) -1)
4480 else if (outrel
.r_offset
== (bfd_vma
) -2)
4481 skip
= TRUE
, relocate
= TRUE
;
4482 outrel
.r_offset
+= (input_section
->output_section
->vma
4483 + input_section
->output_offset
);
4486 memset (&outrel
, 0, sizeof outrel
);
4489 && (r_type
== R_386_PC32
4490 || !(bfd_link_executable (info
)
4491 || SYMBOLIC_BIND (info
, h
))
4492 || !h
->def_regular
))
4493 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4496 /* This symbol is local, or marked to become local. */
4498 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4501 sreloc
= elf_section_data (input_section
)->sreloc
;
4503 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4505 r
= bfd_reloc_notsupported
;
4506 goto check_relocation_error
;
4509 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4511 /* If this reloc is against an external symbol, we do
4512 not want to fiddle with the addend. Otherwise, we
4513 need to include the symbol value so that it becomes
4514 an addend for the dynamic reloc. */
4521 if (!bfd_link_executable (info
))
4523 Elf_Internal_Rela outrel
;
4526 outrel
.r_offset
= rel
->r_offset
4527 + input_section
->output_section
->vma
4528 + input_section
->output_offset
;
4529 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
4530 sreloc
= elf_section_data (input_section
)->sreloc
;
4533 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4538 case R_386_TLS_GOTDESC
:
4539 case R_386_TLS_DESC_CALL
:
4540 case R_386_TLS_IE_32
:
4541 case R_386_TLS_GOTIE
:
4542 tls_type
= GOT_UNKNOWN
;
4543 if (h
== NULL
&& local_got_offsets
)
4544 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
4546 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
4547 if (tls_type
== GOT_TLS_IE
)
4548 tls_type
= GOT_TLS_IE_NEG
;
4550 if (! elf_i386_tls_transition (info
, input_bfd
,
4551 input_section
, contents
,
4552 symtab_hdr
, sym_hashes
,
4553 &r_type
, tls_type
, rel
,
4554 relend
, h
, r_symndx
, TRUE
))
4557 if (r_type
== R_386_TLS_LE_32
)
4559 BFD_ASSERT (! unresolved_reloc
);
4560 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4565 /* GD->LE transition. */
4566 type
= *(contents
+ rel
->r_offset
- 2);
4570 leal foo@tlsgd(,%ebx,1), %eax
4571 call ___tls_get_addr@PLT
4574 subl $foo@tpoff, %eax
4575 (6 byte form of subl). */
4576 roff
= rel
->r_offset
+ 5;
4581 leal foo@tlsgd(%ebx), %eax
4582 call ___tls_get_addr@PLT
4585 leal foo@tlsgd(%reg), %eax
4586 call *___tls_get_addr@GOT(%reg)
4587 which may be converted to
4588 addr32 call ___tls_get_addr
4590 movl %gs:0, %eax; subl $foo@tpoff, %eax
4591 (6 byte form of subl). */
4592 roff
= rel
->r_offset
+ 6;
4594 memcpy (contents
+ roff
- 8,
4595 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4596 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4598 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4603 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4605 /* GDesc -> LE transition.
4606 It's originally something like:
4607 leal x@tlsdesc(%ebx), %eax
4611 Registers other than %eax may be set up here. */
4616 roff
= rel
->r_offset
;
4617 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4619 /* Now modify the instruction as appropriate. */
4620 /* aoliva FIXME: remove the above and xor the byte
4622 bfd_put_8 (output_bfd
, val
^ 0x86,
4623 contents
+ roff
- 1);
4624 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4628 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4630 /* GDesc -> LE transition.
4638 roff
= rel
->r_offset
;
4639 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4640 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4643 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
4647 /* IE->LE transition:
4648 Originally it can be one of:
4656 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4659 /* movl foo, %eax. */
4660 bfd_put_8 (output_bfd
, 0xb8,
4661 contents
+ rel
->r_offset
- 1);
4667 type
= bfd_get_8 (input_bfd
,
4668 contents
+ rel
->r_offset
- 2);
4673 bfd_put_8 (output_bfd
, 0xc7,
4674 contents
+ rel
->r_offset
- 2);
4675 bfd_put_8 (output_bfd
,
4676 0xc0 | ((val
>> 3) & 7),
4677 contents
+ rel
->r_offset
- 1);
4681 bfd_put_8 (output_bfd
, 0x81,
4682 contents
+ rel
->r_offset
- 2);
4683 bfd_put_8 (output_bfd
,
4684 0xc0 | ((val
>> 3) & 7),
4685 contents
+ rel
->r_offset
- 1);
4692 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4693 contents
+ rel
->r_offset
);
4698 unsigned int val
, type
;
4700 /* {IE_32,GOTIE}->LE transition:
4701 Originally it can be one of:
4702 subl foo(%reg1), %reg2
4703 movl foo(%reg1), %reg2
4704 addl foo(%reg1), %reg2
4707 movl $foo, %reg2 (6 byte form)
4708 addl $foo, %reg2. */
4709 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
4710 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
4714 bfd_put_8 (output_bfd
, 0xc7,
4715 contents
+ rel
->r_offset
- 2);
4716 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4717 contents
+ rel
->r_offset
- 1);
4719 else if (type
== 0x2b)
4722 bfd_put_8 (output_bfd
, 0x81,
4723 contents
+ rel
->r_offset
- 2);
4724 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
4725 contents
+ rel
->r_offset
- 1);
4727 else if (type
== 0x03)
4730 bfd_put_8 (output_bfd
, 0x81,
4731 contents
+ rel
->r_offset
- 2);
4732 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4733 contents
+ rel
->r_offset
- 1);
4737 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
4738 bfd_put_32 (output_bfd
, -elf_i386_tpoff (info
, relocation
),
4739 contents
+ rel
->r_offset
);
4741 bfd_put_32 (output_bfd
, elf_i386_tpoff (info
, relocation
),
4742 contents
+ rel
->r_offset
);
4747 if (htab
->elf
.sgot
== NULL
)
4752 off
= h
->got
.offset
;
4753 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
4757 if (local_got_offsets
== NULL
)
4760 off
= local_got_offsets
[r_symndx
];
4761 offplt
= local_tlsdesc_gotents
[r_symndx
];
4768 Elf_Internal_Rela outrel
;
4772 if (htab
->elf
.srelgot
== NULL
)
4775 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4777 if (GOT_TLS_GDESC_P (tls_type
))
4780 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
4781 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
4782 <= htab
->elf
.sgotplt
->size
);
4783 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4784 + htab
->elf
.sgotplt
->output_offset
4786 + htab
->sgotplt_jump_table_size
);
4787 sreloc
= htab
->elf
.srelplt
;
4788 loc
= sreloc
->contents
;
4789 loc
+= (htab
->next_tls_desc_index
++
4790 * sizeof (Elf32_External_Rel
));
4791 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
4792 <= sreloc
->contents
+ sreloc
->size
);
4793 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
4796 BFD_ASSERT (! unresolved_reloc
);
4797 bfd_put_32 (output_bfd
,
4798 relocation
- elf_i386_dtpoff_base (info
),
4799 htab
->elf
.sgotplt
->contents
+ offplt
4800 + htab
->sgotplt_jump_table_size
+ 4);
4804 bfd_put_32 (output_bfd
, 0,
4805 htab
->elf
.sgotplt
->contents
+ offplt
4806 + htab
->sgotplt_jump_table_size
+ 4);
4810 sreloc
= htab
->elf
.srelgot
;
4812 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4813 + htab
->elf
.sgot
->output_offset
+ off
);
4815 if (GOT_TLS_GD_P (tls_type
))
4816 dr_type
= R_386_TLS_DTPMOD32
;
4817 else if (GOT_TLS_GDESC_P (tls_type
))
4819 else if (tls_type
== GOT_TLS_IE_POS
)
4820 dr_type
= R_386_TLS_TPOFF
;
4822 dr_type
= R_386_TLS_TPOFF32
;
4824 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
4825 bfd_put_32 (output_bfd
,
4826 relocation
- elf_i386_dtpoff_base (info
),
4827 htab
->elf
.sgot
->contents
+ off
);
4828 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
4829 bfd_put_32 (output_bfd
,
4830 elf_i386_dtpoff_base (info
) - relocation
,
4831 htab
->elf
.sgot
->contents
+ off
);
4832 else if (dr_type
!= R_386_TLS_DESC
)
4833 bfd_put_32 (output_bfd
, 0,
4834 htab
->elf
.sgot
->contents
+ off
);
4835 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
4837 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4839 if (GOT_TLS_GD_P (tls_type
))
4843 BFD_ASSERT (! unresolved_reloc
);
4844 bfd_put_32 (output_bfd
,
4845 relocation
- elf_i386_dtpoff_base (info
),
4846 htab
->elf
.sgot
->contents
+ off
+ 4);
4850 bfd_put_32 (output_bfd
, 0,
4851 htab
->elf
.sgot
->contents
+ off
+ 4);
4852 outrel
.r_info
= ELF32_R_INFO (indx
,
4853 R_386_TLS_DTPOFF32
);
4854 outrel
.r_offset
+= 4;
4855 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4858 else if (tls_type
== GOT_TLS_IE_BOTH
)
4860 bfd_put_32 (output_bfd
,
4862 ? relocation
- elf_i386_dtpoff_base (info
)
4864 htab
->elf
.sgot
->contents
+ off
+ 4);
4865 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
4866 outrel
.r_offset
+= 4;
4867 elf_append_rel (output_bfd
, sreloc
, &outrel
);
4874 local_got_offsets
[r_symndx
] |= 1;
4877 if (off
>= (bfd_vma
) -2
4878 && ! GOT_TLS_GDESC_P (tls_type
))
4880 if (r_type
== R_386_TLS_GOTDESC
4881 || r_type
== R_386_TLS_DESC_CALL
)
4883 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
4884 unresolved_reloc
= FALSE
;
4886 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4888 bfd_vma g_o_t
= htab
->elf
.sgotplt
->output_section
->vma
4889 + htab
->elf
.sgotplt
->output_offset
;
4890 relocation
= htab
->elf
.sgot
->output_section
->vma
4891 + htab
->elf
.sgot
->output_offset
+ off
- g_o_t
;
4892 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
4893 && tls_type
== GOT_TLS_IE_BOTH
)
4895 if (r_type
== R_386_TLS_IE
)
4896 relocation
+= g_o_t
;
4897 unresolved_reloc
= FALSE
;
4899 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
4901 unsigned int val
, type
;
4904 /* GD->IE transition. */
4905 type
= *(contents
+ rel
->r_offset
- 2);
4906 val
= *(contents
+ rel
->r_offset
- 1);
4910 leal foo@tlsgd(,%ebx,1), %eax
4911 call ___tls_get_addr@PLT
4914 subl $foo@gottpoff(%ebx), %eax. */
4916 roff
= rel
->r_offset
- 3;
4921 leal foo@tlsgd(%ebx), %eax
4922 call ___tls_get_addr@PLT
4925 leal foo@tlsgd(%reg), %eax
4926 call *___tls_get_addr@GOT(%reg)
4927 which may be converted to
4928 addr32 call ___tls_get_addr
4931 subl $foo@gottpoff(%reg), %eax. */
4932 roff
= rel
->r_offset
- 2;
4934 memcpy (contents
+ roff
,
4935 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4936 contents
[roff
+ 7] = 0x80 | (val
& 7);
4937 /* If foo is used only with foo@gotntpoff(%reg) and
4938 foo@indntpoff, but not with foo@gottpoff(%reg), change
4939 subl $foo@gottpoff(%reg), %eax
4941 addl $foo@gotntpoff(%reg), %eax. */
4942 if (tls_type
== GOT_TLS_IE_POS
)
4943 contents
[roff
+ 6] = 0x03;
4944 bfd_put_32 (output_bfd
,
4945 htab
->elf
.sgot
->output_section
->vma
4946 + htab
->elf
.sgot
->output_offset
+ off
4947 - htab
->elf
.sgotplt
->output_section
->vma
4948 - htab
->elf
.sgotplt
->output_offset
,
4949 contents
+ roff
+ 8);
4950 /* Skip R_386_PLT32 and R_386_GOT32X. */
4955 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
4957 /* GDesc -> IE transition.
4958 It's originally something like:
4959 leal x@tlsdesc(%ebx), %eax
4962 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4964 movl x@gottpoff(%ebx), %eax # before negl %eax
4966 Registers other than %eax may be set up here. */
4970 /* First, make sure it's a leal adding ebx to a 32-bit
4971 offset into any register, although it's probably
4972 almost always going to be eax. */
4973 roff
= rel
->r_offset
;
4975 /* Now modify the instruction as appropriate. */
4976 /* To turn a leal into a movl in the form we use it, it
4977 suffices to change the first byte from 0x8d to 0x8b.
4978 aoliva FIXME: should we decide to keep the leal, all
4979 we have to do is remove the statement below, and
4980 adjust the relaxation of R_386_TLS_DESC_CALL. */
4981 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4983 if (tls_type
== GOT_TLS_IE_BOTH
)
4986 bfd_put_32 (output_bfd
,
4987 htab
->elf
.sgot
->output_section
->vma
4988 + htab
->elf
.sgot
->output_offset
+ off
4989 - htab
->elf
.sgotplt
->output_section
->vma
4990 - htab
->elf
.sgotplt
->output_offset
,
4994 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
4996 /* GDesc -> IE transition.
5004 depending on how we transformed the TLS_GOTDESC above.
5009 roff
= rel
->r_offset
;
5011 /* Now modify the instruction as appropriate. */
5012 if (tls_type
!= GOT_TLS_IE_NEG
)
5015 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5016 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5021 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
5022 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
5032 if (! elf_i386_tls_transition (info
, input_bfd
,
5033 input_section
, contents
,
5034 symtab_hdr
, sym_hashes
,
5035 &r_type
, GOT_UNKNOWN
, rel
,
5036 relend
, h
, r_symndx
, TRUE
))
5039 if (r_type
!= R_386_TLS_LDM
)
5041 /* LD->LE transition. Change
5042 leal foo@tlsldm(%ebx) %eax
5043 call ___tls_get_addr@PLT
5047 leal 0(%esi,1), %esi
5049 leal foo@tlsldm(%reg) %eax
5050 call *___tls_get_addr@GOT(%reg)
5051 which may be converted to
5052 addr32 call ___tls_get_addr
5055 leal 0(%esi), %esi */
5056 BFD_ASSERT (r_type
== R_386_TLS_LE_32
);
5057 if (*(contents
+ rel
->r_offset
+ 4) == 0xff
5058 || *(contents
+ rel
->r_offset
+ 4) == 0x67)
5059 memcpy (contents
+ rel
->r_offset
- 2,
5060 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5062 memcpy (contents
+ rel
->r_offset
- 2,
5063 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5064 /* Skip R_386_PC32/R_386_PLT32. */
5070 if (htab
->elf
.sgot
== NULL
)
5073 off
= htab
->tls_ldm_got
.offset
;
5078 Elf_Internal_Rela outrel
;
5080 if (htab
->elf
.srelgot
== NULL
)
5083 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5084 + htab
->elf
.sgot
->output_offset
+ off
);
5086 bfd_put_32 (output_bfd
, 0,
5087 htab
->elf
.sgot
->contents
+ off
);
5088 bfd_put_32 (output_bfd
, 0,
5089 htab
->elf
.sgot
->contents
+ off
+ 4);
5090 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
5091 elf_append_rel (output_bfd
, htab
->elf
.srelgot
, &outrel
);
5092 htab
->tls_ldm_got
.offset
|= 1;
5094 relocation
= htab
->elf
.sgot
->output_section
->vma
5095 + htab
->elf
.sgot
->output_offset
+ off
5096 - htab
->elf
.sgotplt
->output_section
->vma
5097 - htab
->elf
.sgotplt
->output_offset
;
5098 unresolved_reloc
= FALSE
;
5101 case R_386_TLS_LDO_32
:
5102 if (!bfd_link_executable (info
)
5103 || (input_section
->flags
& SEC_CODE
) == 0)
5104 relocation
-= elf_i386_dtpoff_base (info
);
5106 /* When converting LDO to LE, we must negate. */
5107 relocation
= -elf_i386_tpoff (info
, relocation
);
5110 case R_386_TLS_LE_32
:
5112 if (!bfd_link_executable (info
))
5114 Elf_Internal_Rela outrel
;
5117 outrel
.r_offset
= rel
->r_offset
5118 + input_section
->output_section
->vma
5119 + input_section
->output_offset
;
5120 if (h
!= NULL
&& h
->dynindx
!= -1)
5124 if (r_type
== R_386_TLS_LE_32
)
5125 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
5127 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
5128 sreloc
= elf_section_data (input_section
)->sreloc
;
5131 elf_append_rel (output_bfd
, sreloc
, &outrel
);
5134 else if (r_type
== R_386_TLS_LE_32
)
5135 relocation
= elf_i386_dtpoff_base (info
) - relocation
;
5137 relocation
-= elf_i386_dtpoff_base (info
);
5139 else if (r_type
== R_386_TLS_LE_32
)
5140 relocation
= elf_i386_tpoff (info
, relocation
);
5142 relocation
= -elf_i386_tpoff (info
, relocation
);
5149 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5150 because such sections are not SEC_ALLOC and thus ld.so will
5151 not process them. */
5152 if (unresolved_reloc
5153 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5155 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5156 rel
->r_offset
) != (bfd_vma
) -1)
5159 /* xgettext:c-format */
5160 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5163 (long) rel
->r_offset
,
5165 h
->root
.root
.string
);
5170 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5171 contents
, rel
->r_offset
,
5174 check_relocation_error
:
5175 if (r
!= bfd_reloc_ok
)
5180 name
= h
->root
.root
.string
;
5183 name
= bfd_elf_string_from_elf_section (input_bfd
,
5184 symtab_hdr
->sh_link
,
5189 name
= bfd_section_name (input_bfd
, sec
);
5192 if (r
== bfd_reloc_overflow
)
5193 (*info
->callbacks
->reloc_overflow
)
5194 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5195 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5199 /* xgettext:c-format */
5200 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5201 input_bfd
, input_section
,
5202 (long) rel
->r_offset
, name
, (int) r
);
5213 Elf_Internal_Shdr
*rel_hdr
;
5214 size_t deleted
= rel
- wrel
;
5216 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5217 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5218 if (rel_hdr
->sh_size
== 0)
5220 /* It is too late to remove an empty reloc section. Leave
5222 ??? What is wrong with an empty section??? */
5223 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5226 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5227 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5228 input_section
->reloc_count
-= deleted
;
5234 /* Finish up dynamic symbol handling. We set the contents of various
5235 dynamic sections here. */
5238 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
5239 struct bfd_link_info
*info
,
5240 struct elf_link_hash_entry
*h
,
5241 Elf_Internal_Sym
*sym
)
5243 struct elf_i386_link_hash_table
*htab
;
5244 unsigned plt_entry_size
;
5245 const struct elf_i386_backend_data
*abed
;
5246 struct elf_i386_link_hash_entry
*eh
;
5247 bfd_boolean local_undefweak
;
5249 htab
= elf_i386_hash_table (info
);
5253 abed
= get_elf_i386_backend_data (output_bfd
);
5254 plt_entry_size
= GET_PLT_ENTRY_SIZE (output_bfd
);
5256 eh
= (struct elf_i386_link_hash_entry
*) h
;
5258 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5259 resolved undefined weak symbols in executable so that their
5260 references have value 0 at run-time. */
5261 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5265 if (h
->plt
.offset
!= (bfd_vma
) -1)
5269 Elf_Internal_Rela rel
;
5271 asection
*plt
, *gotplt
, *relplt
;
5273 /* When building a static executable, use .iplt, .igot.plt and
5274 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5275 if (htab
->elf
.splt
!= NULL
)
5277 plt
= htab
->elf
.splt
;
5278 gotplt
= htab
->elf
.sgotplt
;
5279 relplt
= htab
->elf
.srelplt
;
5283 plt
= htab
->elf
.iplt
;
5284 gotplt
= htab
->elf
.igotplt
;
5285 relplt
= htab
->elf
.irelplt
;
5288 /* This symbol has an entry in the procedure linkage table. Set
5291 if ((h
->dynindx
== -1
5293 && !((h
->forced_local
|| bfd_link_executable (info
))
5295 && h
->type
== STT_GNU_IFUNC
))
5301 /* Get the index in the procedure linkage table which
5302 corresponds to this symbol. This is the index of this symbol
5303 in all the symbols for which we are making plt entries. The
5304 first entry in the procedure linkage table is reserved.
5306 Get the offset into the .got table of the entry that
5307 corresponds to this function. Each .got entry is 4 bytes.
5308 The first three are reserved.
5310 For static executables, we don't reserve anything. */
5312 if (plt
== htab
->elf
.splt
)
5314 got_offset
= h
->plt
.offset
/ plt_entry_size
- 1;
5315 got_offset
= (got_offset
+ 3) * 4;
5319 got_offset
= h
->plt
.offset
/ plt_entry_size
;
5320 got_offset
= got_offset
* 4;
5323 /* Fill in the entry in the procedure linkage table. */
5324 if (! bfd_link_pic (info
))
5326 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->plt_entry
,
5327 abed
->plt
->plt_entry_size
);
5328 bfd_put_32 (output_bfd
,
5329 (gotplt
->output_section
->vma
5330 + gotplt
->output_offset
5332 plt
->contents
+ h
->plt
.offset
5333 + abed
->plt
->plt_got_offset
);
5335 if (abed
->is_vxworks
)
5337 int s
, k
, reloc_index
;
5339 /* Create the R_386_32 relocation referencing the GOT
5340 for this PLT entry. */
5342 /* S: Current slot number (zero-based). */
5343 s
= ((h
->plt
.offset
- abed
->plt
->plt_entry_size
)
5344 / abed
->plt
->plt_entry_size
);
5345 /* K: Number of relocations for PLTResolve. */
5346 if (bfd_link_pic (info
))
5347 k
= PLTRESOLVE_RELOCS_SHLIB
;
5349 k
= PLTRESOLVE_RELOCS
;
5350 /* Skip the PLTresolve relocations, and the relocations for
5351 the other PLT slots. */
5352 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
5353 loc
= (htab
->srelplt2
->contents
+ reloc_index
5354 * sizeof (Elf32_External_Rel
));
5356 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5357 + htab
->elf
.splt
->output_offset
5358 + h
->plt
.offset
+ 2),
5359 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5360 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5362 /* Create the R_386_32 relocation referencing the beginning of
5363 the PLT for this GOT entry. */
5364 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5365 + htab
->elf
.sgotplt
->output_offset
5367 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5368 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5369 loc
+ sizeof (Elf32_External_Rel
));
5374 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt
->pic_plt_entry
,
5375 abed
->plt
->plt_entry_size
);
5376 bfd_put_32 (output_bfd
, got_offset
,
5377 plt
->contents
+ h
->plt
.offset
5378 + abed
->plt
->plt_got_offset
);
5381 /* Fill in the entry in the global offset table. Leave the entry
5382 as zero for undefined weak symbol in PIE. No PLT relocation
5383 against undefined weak symbol in PIE. */
5384 if (!local_undefweak
)
5386 bfd_put_32 (output_bfd
,
5387 (plt
->output_section
->vma
5388 + plt
->output_offset
5390 + abed
->plt
->plt_lazy_offset
),
5391 gotplt
->contents
+ got_offset
);
5393 /* Fill in the entry in the .rel.plt section. */
5394 rel
.r_offset
= (gotplt
->output_section
->vma
5395 + gotplt
->output_offset
5397 if (h
->dynindx
== -1
5398 || ((bfd_link_executable (info
)
5399 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5401 && h
->type
== STT_GNU_IFUNC
))
5403 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5404 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5405 in the .got.plt section. */
5406 bfd_put_32 (output_bfd
,
5407 (h
->root
.u
.def
.value
5408 + h
->root
.u
.def
.section
->output_section
->vma
5409 + h
->root
.u
.def
.section
->output_offset
),
5410 gotplt
->contents
+ got_offset
);
5411 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5412 /* R_386_IRELATIVE comes last. */
5413 plt_index
= htab
->next_irelative_index
--;
5417 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
5418 plt_index
= htab
->next_jump_slot_index
++;
5421 loc
= relplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
5422 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
5424 /* Don't fill PLT entry for static executables. */
5425 if (plt
== htab
->elf
.splt
)
5427 bfd_put_32 (output_bfd
,
5428 plt_index
* sizeof (Elf32_External_Rel
),
5429 plt
->contents
+ h
->plt
.offset
5430 + abed
->plt
->plt_reloc_offset
);
5431 bfd_put_32 (output_bfd
, - (h
->plt
.offset
5432 + abed
->plt
->plt_plt_offset
+ 4),
5433 plt
->contents
+ h
->plt
.offset
5434 + abed
->plt
->plt_plt_offset
);
5438 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5440 bfd_vma got_offset
, plt_offset
;
5441 asection
*plt
, *got
, *gotplt
;
5442 const bfd_byte
*got_plt_entry
;
5444 /* Offset of displacement of the indirect jump. */
5445 bfd_vma plt_got_offset
= 2;
5447 /* Set the entry in the GOT procedure linkage table. */
5448 plt
= htab
->plt_got
;
5449 got
= htab
->elf
.sgot
;
5450 gotplt
= htab
->elf
.sgotplt
;
5451 got_offset
= h
->got
.offset
;
5453 if (got_offset
== (bfd_vma
) -1
5459 /* Fill in the entry in the GOT procedure linkage table. */
5460 if (! bfd_link_pic (info
))
5462 got_plt_entry
= elf_i386_got_plt_entry
;
5463 got_offset
+= got
->output_section
->vma
+ got
->output_offset
;
5467 got_plt_entry
= elf_i386_pic_got_plt_entry
;
5468 got_offset
+= (got
->output_section
->vma
5469 + got
->output_offset
5470 - gotplt
->output_section
->vma
5471 - gotplt
->output_offset
);
5474 plt_offset
= eh
->plt_got
.offset
;
5475 memcpy (plt
->contents
+ plt_offset
, got_plt_entry
,
5476 sizeof (elf_i386_got_plt_entry
));
5477 bfd_put_32 (output_bfd
, got_offset
,
5478 plt
->contents
+ plt_offset
+ plt_got_offset
);
5481 if (!local_undefweak
5483 && (h
->plt
.offset
!= (bfd_vma
) -1
5484 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5486 /* Mark the symbol as undefined, rather than as defined in
5487 the .plt section. Leave the value if there were any
5488 relocations where pointer equality matters (this is a clue
5489 for the dynamic linker, to make function pointer
5490 comparisons work between an application and shared
5491 library), otherwise set it to zero. If a function is only
5492 called from a binary, there is no need to slow down
5493 shared libraries because of that. */
5494 sym
->st_shndx
= SHN_UNDEF
;
5495 if (!h
->pointer_equality_needed
)
5499 /* Don't generate dynamic GOT relocation against undefined weak
5500 symbol in executable. */
5501 if (h
->got
.offset
!= (bfd_vma
) -1
5502 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
5503 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0
5504 && !local_undefweak
)
5506 Elf_Internal_Rela rel
;
5507 asection
*relgot
= htab
->elf
.srelgot
;
5509 /* This symbol has an entry in the global offset table. Set it
5512 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5515 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5516 + htab
->elf
.sgot
->output_offset
5517 + (h
->got
.offset
& ~(bfd_vma
) 1));
5519 /* If this is a static link, or it is a -Bsymbolic link and the
5520 symbol is defined locally or was forced to be local because
5521 of a version file, we just want to emit a RELATIVE reloc.
5522 The entry in the global offset table will already have been
5523 initialized in the relocate_section function. */
5525 && h
->type
== STT_GNU_IFUNC
)
5527 if (h
->plt
.offset
== (bfd_vma
) -1)
5529 /* STT_GNU_IFUNC is referenced without PLT. */
5530 if (htab
->elf
.splt
== NULL
)
5532 /* use .rel[a].iplt section to store .got relocations
5533 in static executable. */
5534 relgot
= htab
->elf
.irelplt
;
5536 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5538 bfd_put_32 (output_bfd
,
5539 (h
->root
.u
.def
.value
5540 + h
->root
.u
.def
.section
->output_section
->vma
5541 + h
->root
.u
.def
.section
->output_offset
),
5542 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5543 rel
.r_info
= ELF32_R_INFO (0, R_386_IRELATIVE
);
5548 else if (bfd_link_pic (info
))
5550 /* Generate R_386_GLOB_DAT. */
5557 if (!h
->pointer_equality_needed
)
5560 /* For non-shared object, we can't use .got.plt, which
5561 contains the real function addres if we need pointer
5562 equality. We load the GOT entry with the PLT entry. */
5563 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5564 bfd_put_32 (output_bfd
,
5565 (plt
->output_section
->vma
5566 + plt
->output_offset
+ h
->plt
.offset
),
5567 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5571 else if (bfd_link_pic (info
)
5572 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5574 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5575 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
5579 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5581 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5582 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5583 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
5586 elf_append_rel (output_bfd
, relgot
, &rel
);
5591 Elf_Internal_Rela rel
;
5593 /* This symbol needs a copy reloc. Set it up. */
5595 if (h
->dynindx
== -1
5596 || (h
->root
.type
!= bfd_link_hash_defined
5597 && h
->root
.type
!= bfd_link_hash_defweak
)
5598 || htab
->srelbss
== NULL
)
5601 rel
.r_offset
= (h
->root
.u
.def
.value
5602 + h
->root
.u
.def
.section
->output_section
->vma
5603 + h
->root
.u
.def
.section
->output_offset
);
5604 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
5605 elf_append_rel (output_bfd
, htab
->srelbss
, &rel
);
5611 /* Finish up local dynamic symbol handling. We set the contents of
5612 various dynamic sections here. */
5615 elf_i386_finish_local_dynamic_symbol (void **slot
, void *inf
)
5617 struct elf_link_hash_entry
*h
5618 = (struct elf_link_hash_entry
*) *slot
;
5619 struct bfd_link_info
*info
5620 = (struct bfd_link_info
*) inf
;
5622 return elf_i386_finish_dynamic_symbol (info
->output_bfd
, info
,
5626 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5627 here since undefined weak symbol may not be dynamic and may not be
5628 called for elf_i386_finish_dynamic_symbol. */
5631 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5634 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5635 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5637 if (h
->root
.type
!= bfd_link_hash_undefweak
5638 || h
->dynindx
!= -1)
5641 return elf_i386_finish_dynamic_symbol (info
->output_bfd
,
5645 /* Used to decide how to sort relocs in an optimal manner for the
5646 dynamic linker, before writing them out. */
5648 static enum elf_reloc_type_class
5649 elf_i386_reloc_type_class (const struct bfd_link_info
*info
,
5650 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5651 const Elf_Internal_Rela
*rela
)
5653 bfd
*abfd
= info
->output_bfd
;
5654 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5655 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
5657 if (htab
->dynsym
!= NULL
5658 && htab
->dynsym
->contents
!= NULL
)
5660 /* Check relocation against STT_GNU_IFUNC symbol if there are
5662 unsigned long r_symndx
= ELF32_R_SYM (rela
->r_info
);
5663 if (r_symndx
!= STN_UNDEF
)
5665 Elf_Internal_Sym sym
;
5666 if (!bed
->s
->swap_symbol_in (abfd
,
5667 (htab
->dynsym
->contents
5668 + r_symndx
* sizeof (Elf32_External_Sym
)),
5672 if (ELF32_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5673 return reloc_class_ifunc
;
5677 switch (ELF32_R_TYPE (rela
->r_info
))
5679 case R_386_IRELATIVE
:
5680 return reloc_class_ifunc
;
5681 case R_386_RELATIVE
:
5682 return reloc_class_relative
;
5683 case R_386_JUMP_SLOT
:
5684 return reloc_class_plt
;
5686 return reloc_class_copy
;
5688 return reloc_class_normal
;
5692 /* Finish up the dynamic sections. */
5695 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
5696 struct bfd_link_info
*info
)
5698 struct elf_i386_link_hash_table
*htab
;
5701 const struct elf_i386_backend_data
*abed
;
5703 htab
= elf_i386_hash_table (info
);
5707 dynobj
= htab
->elf
.dynobj
;
5708 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5709 abed
= get_elf_i386_backend_data (output_bfd
);
5711 if (htab
->elf
.dynamic_sections_created
)
5713 Elf32_External_Dyn
*dyncon
, *dynconend
;
5715 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5718 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5719 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5720 for (; dyncon
< dynconend
; dyncon
++)
5722 Elf_Internal_Dyn dyn
;
5725 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5730 if (abed
->is_vxworks
5731 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
5736 s
= htab
->elf
.sgotplt
;
5737 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5741 s
= htab
->elf
.srelplt
;
5742 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5746 s
= htab
->elf
.srelplt
;
5747 dyn
.d_un
.d_val
= s
->size
;
5751 /* My reading of the SVR4 ABI indicates that the
5752 procedure linkage table relocs (DT_JMPREL) should be
5753 included in the overall relocs (DT_REL). This is
5754 what Solaris does. However, UnixWare can not handle
5755 that case. Therefore, we override the DT_RELSZ entry
5756 here to make it not include the JMPREL relocs. */
5757 s
= htab
->elf
.srelplt
;
5760 dyn
.d_un
.d_val
-= s
->size
;
5764 /* We may not be using the standard ELF linker script.
5765 If .rel.plt is the first .rel section, we adjust
5766 DT_REL to not include it. */
5767 s
= htab
->elf
.srelplt
;
5770 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
5772 dyn
.d_un
.d_ptr
+= s
->size
;
5776 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5779 /* Fill in the first entry in the procedure linkage table. */
5780 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5782 if (bfd_link_pic (info
))
5784 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->pic_plt0_entry
,
5785 abed
->plt
->plt0_entry_size
);
5786 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5787 abed
->plt0_pad_byte
,
5788 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5792 memcpy (htab
->elf
.splt
->contents
, abed
->plt
->plt0_entry
,
5793 abed
->plt
->plt0_entry_size
);
5794 memset (htab
->elf
.splt
->contents
+ abed
->plt
->plt0_entry_size
,
5795 abed
->plt0_pad_byte
,
5796 abed
->plt
->plt_entry_size
- abed
->plt
->plt0_entry_size
);
5797 bfd_put_32 (output_bfd
,
5798 (htab
->elf
.sgotplt
->output_section
->vma
5799 + htab
->elf
.sgotplt
->output_offset
5801 htab
->elf
.splt
->contents
5802 + abed
->plt
->plt0_got1_offset
);
5803 bfd_put_32 (output_bfd
,
5804 (htab
->elf
.sgotplt
->output_section
->vma
5805 + htab
->elf
.sgotplt
->output_offset
5807 htab
->elf
.splt
->contents
5808 + abed
->plt
->plt0_got2_offset
);
5810 if (abed
->is_vxworks
)
5812 Elf_Internal_Rela rel
;
5814 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5815 On IA32 we use REL relocations so the addend goes in
5816 the PLT directly. */
5817 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5818 + htab
->elf
.splt
->output_offset
5819 + abed
->plt
->plt0_got1_offset
);
5820 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5821 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5822 htab
->srelplt2
->contents
);
5823 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5824 rel
.r_offset
= (htab
->elf
.splt
->output_section
->vma
5825 + htab
->elf
.splt
->output_offset
5826 + abed
->plt
->plt0_got2_offset
);
5827 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5828 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
5829 htab
->srelplt2
->contents
+
5830 sizeof (Elf32_External_Rel
));
5834 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5835 really seem like the right value. */
5836 elf_section_data (htab
->elf
.splt
->output_section
)
5837 ->this_hdr
.sh_entsize
= 4;
5839 /* Correct the .rel.plt.unloaded relocations. */
5840 if (abed
->is_vxworks
&& !bfd_link_pic (info
))
5842 int num_plts
= (htab
->elf
.splt
->size
5843 / abed
->plt
->plt_entry_size
) - 1;
5846 p
= htab
->srelplt2
->contents
;
5847 if (bfd_link_pic (info
))
5848 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
5850 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
5852 for (; num_plts
; num_plts
--)
5854 Elf_Internal_Rela rel
;
5855 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5856 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
5857 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5858 p
+= sizeof (Elf32_External_Rel
);
5860 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
5861 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
5862 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
5863 p
+= sizeof (Elf32_External_Rel
);
5869 if (htab
->elf
.sgotplt
)
5871 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5874 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5878 /* Fill in the first three entries in the global offset table. */
5879 if (htab
->elf
.sgotplt
->size
> 0)
5881 bfd_put_32 (output_bfd
,
5883 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
5884 htab
->elf
.sgotplt
->contents
);
5885 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 4);
5886 bfd_put_32 (output_bfd
, 0, htab
->elf
.sgotplt
->contents
+ 8);
5889 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5892 /* Adjust .eh_frame for .plt section. */
5893 if (htab
->plt_eh_frame
!= NULL
5894 && htab
->plt_eh_frame
->contents
!= NULL
)
5896 if (htab
->elf
.splt
!= NULL
5897 && htab
->elf
.splt
->size
!= 0
5898 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5899 && htab
->elf
.splt
->output_section
!= NULL
5900 && htab
->plt_eh_frame
->output_section
!= NULL
)
5902 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5903 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5904 + htab
->plt_eh_frame
->output_offset
5905 + PLT_FDE_START_OFFSET
;
5906 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5907 htab
->plt_eh_frame
->contents
5908 + PLT_FDE_START_OFFSET
);
5910 if (htab
->plt_eh_frame
->sec_info_type
5911 == SEC_INFO_TYPE_EH_FRAME
)
5913 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5915 htab
->plt_eh_frame
->contents
))
5920 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5921 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5923 /* Fill PLT entries for undefined weak symbols in PIE. */
5924 if (bfd_link_pie (info
))
5925 bfd_hash_traverse (&info
->hash
->table
,
5926 elf_i386_pie_finish_undefweak_symbol
,
5932 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5933 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5934 It has to be done before elf_link_sort_relocs is called so that
5935 dynamic relocations are properly sorted. */
5938 elf_i386_output_arch_local_syms
5939 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5940 struct bfd_link_info
*info
,
5941 void *flaginfo ATTRIBUTE_UNUSED
,
5942 int (*func
) (void *, const char *,
5945 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5947 struct elf_i386_link_hash_table
*htab
= elf_i386_hash_table (info
);
5951 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5952 htab_traverse (htab
->loc_hash_table
,
5953 elf_i386_finish_local_dynamic_symbol
,
5959 /* Return an array of PLT entry symbol values. */
5962 elf_i386_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5965 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5968 bfd_vma
*plt_sym_val
;
5970 bfd_byte
*plt_contents
;
5971 const struct elf_i386_backend_data
*bed
5972 = get_elf_i386_backend_data (abfd
);
5973 Elf_Internal_Shdr
*hdr
;
5975 /* Get the .plt section contents. */
5976 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5977 if (plt_contents
== NULL
)
5979 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5980 plt_contents
, 0, plt
->size
))
5983 free (plt_contents
);
5987 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5988 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5991 hdr
= &elf_section_data (relplt
)->this_hdr
;
5992 count
= relplt
->size
/ hdr
->sh_entsize
;
5994 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5995 if (plt_sym_val
== NULL
)
5998 for (i
= 0; i
< count
; i
++)
5999 plt_sym_val
[i
] = -1;
6001 plt_offset
= bed
->plt
->plt_entry_size
;
6002 p
= relplt
->relocation
;
6003 for (i
= 0; i
< count
; i
++, p
++)
6007 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
6008 if (p
->howto
== NULL
)
6011 if (p
->howto
->type
!= R_386_JUMP_SLOT
6012 && p
->howto
->type
!= R_386_IRELATIVE
)
6015 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6016 + bed
->plt
->plt_reloc_offset
));
6017 reloc_index
/= sizeof (Elf32_External_Rel
);
6018 if (reloc_index
< count
)
6019 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6021 plt_offset
+= bed
->plt
->plt_entry_size
;
6023 /* PR binutils/18437: Skip extra relocations in the .rel.plt
6025 if (plt_offset
>= plt
->size
)
6029 free (plt_contents
);
6034 /* Similar to _bfd_elf_get_synthetic_symtab. */
6037 elf_i386_get_synthetic_symtab (bfd
*abfd
,
6044 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt");
6045 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6046 dynsymcount
, dynsyms
, ret
,
6048 elf_i386_get_plt_sym_val
);
6051 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6054 elf_i386_hash_symbol (struct elf_link_hash_entry
*h
)
6056 if (h
->plt
.offset
!= (bfd_vma
) -1
6058 && !h
->pointer_equality_needed
)
6061 return _bfd_elf_hash_symbol (h
);
6064 #define TARGET_LITTLE_SYM i386_elf32_vec
6065 #define TARGET_LITTLE_NAME "elf32-i386"
6066 #define ELF_ARCH bfd_arch_i386
6067 #define ELF_TARGET_ID I386_ELF_DATA
6068 #define ELF_MACHINE_CODE EM_386
6069 #define ELF_MAXPAGESIZE 0x1000
6071 #define elf_backend_can_gc_sections 1
6072 #define elf_backend_can_refcount 1
6073 #define elf_backend_want_got_plt 1
6074 #define elf_backend_plt_readonly 1
6075 #define elf_backend_want_plt_sym 0
6076 #define elf_backend_got_header_size 12
6077 #define elf_backend_plt_alignment 4
6078 #define elf_backend_extern_protected_data 1
6079 #define elf_backend_caches_rawsize 1
6081 /* Support RELA for objdump of prelink objects. */
6082 #define elf_info_to_howto elf_i386_info_to_howto_rel
6083 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6085 #define bfd_elf32_mkobject elf_i386_mkobject
6087 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6088 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6089 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6090 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6091 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6093 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6094 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6095 #define elf_backend_check_relocs elf_i386_check_relocs
6096 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6097 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
6098 #define elf_backend_fake_sections elf_i386_fake_sections
6099 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6100 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6101 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6102 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6103 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6104 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6105 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6106 #define elf_backend_relocate_section elf_i386_relocate_section
6107 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6108 #define elf_backend_always_size_sections elf_i386_always_size_sections
6109 #define elf_backend_omit_section_dynsym \
6110 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6111 #define elf_backend_hash_symbol elf_i386_hash_symbol
6112 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6114 #include "elf32-target.h"
6116 /* FreeBSD support. */
6118 #undef TARGET_LITTLE_SYM
6119 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6120 #undef TARGET_LITTLE_NAME
6121 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6123 #define ELF_OSABI ELFOSABI_FREEBSD
6125 /* The kernel recognizes executables as valid only if they carry a
6126 "FreeBSD" label in the ELF header. So we put this label on all
6127 executables and (for simplicity) also all other object files. */
6130 elf_i386_fbsd_post_process_headers (bfd
*abfd
, struct bfd_link_info
*info
)
6132 _bfd_elf_post_process_headers (abfd
, info
);
6134 #ifdef OLD_FREEBSD_ABI_LABEL
6136 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6137 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6138 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
6143 #undef elf_backend_post_process_headers
6144 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6146 #define elf32_bed elf32_i386_fbsd_bed
6148 #undef elf_backend_add_symbol_hook
6150 #include "elf32-target.h"
6154 #undef TARGET_LITTLE_SYM
6155 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6156 #undef TARGET_LITTLE_NAME
6157 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6159 #undef elf_backend_post_process_headers
6161 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6162 objects won't be recognized. */
6166 #define elf32_bed elf32_i386_sol2_bed
6168 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6170 #undef elf_backend_static_tls_alignment
6171 #define elf_backend_static_tls_alignment 8
6173 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6175 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6177 #undef elf_backend_want_plt_sym
6178 #define elf_backend_want_plt_sym 1
6180 #undef elf_backend_strtab_flags
6181 #define elf_backend_strtab_flags SHF_STRINGS
6183 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6184 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6185 FALSE otherwise. ISECTION is the best guess matching section from the
6186 input bfd IBFD, but it might be NULL. */
6189 elf32_i386_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6190 bfd
*obfd ATTRIBUTE_UNUSED
,
6191 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6192 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6194 /* PR 19938: FIXME: Need to add code for setting the sh_info
6195 and sh_link fields of Solaris specific section types. */
6198 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6199 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6201 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6203 The following values should be set:
6206 -----------------------------------------------------------------------------
6207 SHT_SUNW_ancillary The section header index of 0
6208 [0x6fffffee] the associated string table.
6210 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6211 [0x6ffffff0] the associated symbol table. section header index of
6213 SHT_SUNW_capchain table,
6216 SHT_SUNW_symsort The section header index of 0
6217 [0x6ffffff1] the associated symbol table.
6219 SHT_SUNW_tlssort The section header index of 0
6220 [0x6ffffff2] the associated symbol table.
6222 SHT_SUNW_LDYNSYM The section header index of One greater than the
6223 [0x6ffffff3] the associated string table. symbol table index of the
6224 This index is the same string last local symbol,
6225 table used by the SHT_DYNSYM STB_LOCAL. Since
6226 section. SHT_SUNW_LDYNSYM only
6227 contains local symbols,
6228 sh_info is equivalent to
6229 the number of symbols in
6232 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6233 [0x6ffffff5] the section header index of to named strings, the
6234 the associated section header index of
6235 SHT_SUNW_capinfo table, the associated string
6236 otherwise 0. table, otherwise 0.
6238 SHT_SUNW_move The section header index of 0
6239 [0x6ffffffa] the associated symbol table.
6244 SHT_SUNW_syminfo The section header index of The section header index
6245 [0x6ffffffc] the associated symbol table. of the associated
6248 SHT_SUNW_verdef The section header index of The number of version
6249 [0x6ffffffd] the associated string table. definitions within the
6252 SHT_SUNW_verneed The section header index of The number of version
6253 [0x6ffffffe] the associated string table. dependencies within the
6256 SHT_SUNW_versym The section header index of 0
6257 [0x6fffffff] the associated symbol table. */
6260 #undef elf_backend_copy_special_section_fields
6261 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6263 #include "elf32-target.h"
6265 /* Intel MCU support. */
6268 elf32_iamcu_elf_object_p (bfd
*abfd
)
6270 /* Set the right machine number for an IAMCU elf32 file. */
6271 bfd_default_set_arch_mach (abfd
, bfd_arch_iamcu
, bfd_mach_i386_iamcu
);
6275 #undef TARGET_LITTLE_SYM
6276 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6277 #undef TARGET_LITTLE_NAME
6278 #define TARGET_LITTLE_NAME "elf32-iamcu"
6280 #define ELF_ARCH bfd_arch_iamcu
6282 #undef ELF_MACHINE_CODE
6283 #define ELF_MACHINE_CODE EM_IAMCU
6288 #define elf32_bed elf32_iamcu_bed
6290 #undef elf_backend_object_p
6291 #define elf_backend_object_p elf32_iamcu_elf_object_p
6293 #undef elf_backend_static_tls_alignment
6295 #undef elf_backend_want_plt_sym
6296 #define elf_backend_want_plt_sym 0
6298 #undef elf_backend_strtab_flags
6299 #undef elf_backend_copy_special_section_fields
6301 #include "elf32-target.h"
6303 /* Restore defaults. */
6305 #define ELF_ARCH bfd_arch_i386
6306 #undef ELF_MACHINE_CODE
6307 #define ELF_MACHINE_CODE EM_386
6309 /* Native Client support. */
6311 #undef TARGET_LITTLE_SYM
6312 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6313 #undef TARGET_LITTLE_NAME
6314 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6316 #define elf32_bed elf32_i386_nacl_bed
6318 #undef ELF_MAXPAGESIZE
6319 #define ELF_MAXPAGESIZE 0x10000
6321 /* Restore defaults. */
6323 #undef elf_backend_want_plt_sym
6324 #define elf_backend_want_plt_sym 0
6325 #undef elf_backend_post_process_headers
6326 #undef elf_backend_static_tls_alignment
6328 /* NaCl uses substantially different PLT entries for the same effects. */
6330 #undef elf_backend_plt_alignment
6331 #define elf_backend_plt_alignment 5
6332 #define NACL_PLT_ENTRY_SIZE 64
6333 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6335 static const bfd_byte elf_i386_nacl_plt0_entry
[] =
6337 0xff, 0x35, /* pushl contents of address */
6338 0, 0, 0, 0, /* replaced with address of .got + 4. */
6339 0x8b, 0x0d, /* movl contents of address, %ecx */
6340 0, 0, 0, 0, /* replaced with address of .got + 8. */
6341 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6342 0xff, 0xe1 /* jmp *%ecx */
6345 static const bfd_byte elf_i386_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6347 0x8b, 0x0d, /* movl contents of address, %ecx */
6348 0, 0, 0, 0, /* replaced with GOT slot address. */
6349 0x83, 0xe1, NACLMASK
, /* andl $NACLMASK, %ecx */
6350 0xff, 0xe1, /* jmp *%ecx */
6352 /* Pad to the next 32-byte boundary with nop instructions. */
6354 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6355 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6357 /* Lazy GOT entries point here (32-byte aligned). */
6358 0x68, /* pushl immediate */
6359 0, 0, 0, 0, /* replaced with reloc offset. */
6360 0xe9, /* jmp relative */
6361 0, 0, 0, 0, /* replaced with offset to .plt. */
6363 /* Pad to the next 32-byte boundary with nop instructions. */
6364 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6365 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6369 static const bfd_byte
6370 elf_i386_nacl_pic_plt0_entry
[sizeof (elf_i386_nacl_plt0_entry
)] =
6372 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6373 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6374 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6375 0xff, 0xe1, /* jmp *%ecx */
6377 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6378 so pad to that size with nop instructions. */
6379 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6382 static const bfd_byte elf_i386_nacl_pic_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6384 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6385 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6386 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6387 0xff, 0xe1, /* jmp *%ecx */
6389 /* Pad to the next 32-byte boundary with nop instructions. */
6391 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6392 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6394 /* Lazy GOT entries point here (32-byte aligned). */
6395 0x68, /* pushl immediate */
6396 0, 0, 0, 0, /* replaced with offset into relocation table. */
6397 0xe9, /* jmp relative */
6398 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6400 /* Pad to the next 32-byte boundary with nop instructions. */
6401 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6402 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6406 static const bfd_byte elf_i386_nacl_eh_frame_plt
[] =
6408 #if (PLT_CIE_LENGTH != 20 \
6409 || PLT_FDE_LENGTH != 36 \
6410 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6411 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6412 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6414 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6415 0, 0, 0, 0, /* CIE ID */
6416 1, /* CIE version */
6417 'z', 'R', 0, /* Augmentation string */
6418 1, /* Code alignment factor */
6419 0x7c, /* Data alignment factor: -4 */
6420 8, /* Return address column */
6421 1, /* Augmentation size */
6422 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6423 DW_CFA_def_cfa
, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6424 DW_CFA_offset
+ 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6425 DW_CFA_nop
, DW_CFA_nop
,
6427 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6428 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
6429 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6430 0, 0, 0, 0, /* .plt size goes here */
6431 0, /* Augmentation size */
6432 DW_CFA_def_cfa_offset
, 8, /* DW_CFA_def_cfa_offset: 8 */
6433 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6434 DW_CFA_def_cfa_offset
, 12, /* DW_CFA_def_cfa_offset: 12 */
6435 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6436 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6437 13, /* Block length */
6438 DW_OP_breg4
, 4, /* DW_OP_breg4 (esp): 4 */
6439 DW_OP_breg8
, 0, /* DW_OP_breg8 (eip): 0 */
6440 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6441 DW_OP_lit2
, DW_OP_shl
, DW_OP_plus
,
6442 DW_CFA_nop
, DW_CFA_nop
6445 static const struct elf_i386_plt_layout elf_i386_nacl_plt
=
6447 elf_i386_nacl_plt0_entry
, /* plt0_entry */
6448 sizeof (elf_i386_nacl_plt0_entry
), /* plt0_entry_size */
6449 2, /* plt0_got1_offset */
6450 8, /* plt0_got2_offset */
6451 elf_i386_nacl_plt_entry
, /* plt_entry */
6452 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6453 2, /* plt_got_offset */
6454 33, /* plt_reloc_offset */
6455 38, /* plt_plt_offset */
6456 32, /* plt_lazy_offset */
6457 elf_i386_nacl_pic_plt0_entry
, /* pic_plt0_entry */
6458 elf_i386_nacl_pic_plt_entry
, /* pic_plt_entry */
6459 elf_i386_nacl_eh_frame_plt
, /* eh_frame_plt */
6460 sizeof (elf_i386_nacl_eh_frame_plt
),/* eh_frame_plt_size */
6463 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed
=
6465 &elf_i386_nacl_plt
, /* plt */
6466 0x90, /* plt0_pad_byte: nop insn */
6471 elf32_i386_nacl_elf_object_p (bfd
*abfd
)
6473 /* Set the right machine number for a NaCl i386 ELF32 file. */
6474 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_i386_i386_nacl
);
6478 #undef elf_backend_arch_data
6479 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6481 #undef elf_backend_object_p
6482 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6483 #undef elf_backend_modify_segment_map
6484 #define elf_backend_modify_segment_map nacl_modify_segment_map
6485 #undef elf_backend_modify_program_headers
6486 #define elf_backend_modify_program_headers nacl_modify_program_headers
6487 #undef elf_backend_final_write_processing
6488 #define elf_backend_final_write_processing nacl_final_write_processing
6490 #include "elf32-target.h"
6492 /* Restore defaults. */
6493 #undef elf_backend_object_p
6494 #undef elf_backend_modify_segment_map
6495 #undef elf_backend_modify_program_headers
6496 #undef elf_backend_final_write_processing
6498 /* VxWorks support. */
6500 #undef TARGET_LITTLE_SYM
6501 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6502 #undef TARGET_LITTLE_NAME
6503 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6505 #undef elf_backend_plt_alignment
6506 #define elf_backend_plt_alignment 4
6508 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed
=
6510 &elf_i386_plt
, /* plt */
6511 0x90, /* plt0_pad_byte */
6515 #undef elf_backend_arch_data
6516 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6518 #undef elf_backend_relocs_compatible
6519 #undef elf_backend_add_symbol_hook
6520 #define elf_backend_add_symbol_hook \
6521 elf_vxworks_add_symbol_hook
6522 #undef elf_backend_link_output_symbol_hook
6523 #define elf_backend_link_output_symbol_hook \
6524 elf_vxworks_link_output_symbol_hook
6525 #undef elf_backend_emit_relocs
6526 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6527 #undef elf_backend_final_write_processing
6528 #define elf_backend_final_write_processing \
6529 elf_vxworks_final_write_processing
6530 #undef elf_backend_static_tls_alignment
6532 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6534 #undef elf_backend_want_plt_sym
6535 #define elf_backend_want_plt_sym 1
6538 #define elf32_bed elf32_i386_vxworks_bed
6540 #include "elf32-target.h"