projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
daily update
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf-nacl.h"
29 #include "elf-vxworks.h"
30 #include "bfd_stdint.h"
31 #include "objalloc.h"
32 #include "hashtab.h"
33 #include "dwarf2.h"
34
35 /* 386 uses REL relocations instead of RELA. */
36 #define USE_REL 1
37
38 #include "elf/i386.h"
39
40 static reloc_howto_type elf_howto_table[]=
41 {
42 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
43 bfd_elf_generic_reloc, "R_386_NONE",
44 TRUE, 0x00000000, 0x00000000, FALSE),
45 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
46 bfd_elf_generic_reloc, "R_386_32",
47 TRUE, 0xffffffff, 0xffffffff, FALSE),
48 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
49 bfd_elf_generic_reloc, "R_386_PC32",
50 TRUE, 0xffffffff, 0xffffffff, TRUE),
51 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
52 bfd_elf_generic_reloc, "R_386_GOT32",
53 TRUE, 0xffffffff, 0xffffffff, FALSE),
54 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
55 bfd_elf_generic_reloc, "R_386_PLT32",
56 TRUE, 0xffffffff, 0xffffffff, TRUE),
57 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
58 bfd_elf_generic_reloc, "R_386_COPY",
59 TRUE, 0xffffffff, 0xffffffff, FALSE),
60 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
62 TRUE, 0xffffffff, 0xffffffff, FALSE),
63 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
65 TRUE, 0xffffffff, 0xffffffff, FALSE),
66 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_386_RELATIVE",
68 TRUE, 0xffffffff, 0xffffffff, FALSE),
69 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_386_GOTOFF",
71 TRUE, 0xffffffff, 0xffffffff, FALSE),
72 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_386_GOTPC",
74 TRUE, 0xffffffff, 0xffffffff, TRUE),
75
76 /* We have a gap in the reloc numbers here.
77 R_386_standard counts the number up to this point, and
78 R_386_ext_offset is the value to subtract from a reloc type of
79 R_386_16 thru R_386_PC8 to form an index into this table. */
80 #define R_386_standard (R_386_GOTPC + 1)
81 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82
83 /* These relocs are a GNU extension. */
84 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
86 TRUE, 0xffffffff, 0xffffffff, FALSE),
87 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_386_TLS_IE",
89 TRUE, 0xffffffff, 0xffffffff, FALSE),
90 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
92 TRUE, 0xffffffff, 0xffffffff, FALSE),
93 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
94 bfd_elf_generic_reloc, "R_386_TLS_LE",
95 TRUE, 0xffffffff, 0xffffffff, FALSE),
96 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_386_TLS_GD",
98 TRUE, 0xffffffff, 0xffffffff, FALSE),
99 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
100 bfd_elf_generic_reloc, "R_386_TLS_LDM",
101 TRUE, 0xffffffff, 0xffffffff, FALSE),
102 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_16",
104 TRUE, 0xffff, 0xffff, FALSE),
105 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_PC16",
107 TRUE, 0xffff, 0xffff, TRUE),
108 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_8",
110 TRUE, 0xff, 0xff, FALSE),
111 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_386_PC8",
113 TRUE, 0xff, 0xff, TRUE),
114
115 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
116 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
117 /* These are common with Solaris TLS implementation. */
118 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
119 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
120 TRUE, 0xffffffff, 0xffffffff, FALSE),
121 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
122 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
123 TRUE, 0xffffffff, 0xffffffff, FALSE),
124 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
125 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
126 TRUE, 0xffffffff, 0xffffffff, FALSE),
127 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
129 TRUE, 0xffffffff, 0xffffffff, FALSE),
130 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
131 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
132 TRUE, 0xffffffff, 0xffffffff, FALSE),
133 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
134 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
135 TRUE, 0xffffffff, 0xffffffff, FALSE),
136 EMPTY_HOWTO (38),
137 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
139 TRUE, 0xffffffff, 0xffffffff, FALSE),
140 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
141 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
142 FALSE, 0, 0, FALSE),
143 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_386_TLS_DESC",
145 TRUE, 0xffffffff, 0xffffffff, FALSE),
146 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
147 bfd_elf_generic_reloc, "R_386_IRELATIVE",
148 TRUE, 0xffffffff, 0xffffffff, FALSE),
149
150 /* Another gap. */
151 #define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
152 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
153
154 /* GNU extension to record C++ vtable hierarchy. */
155 HOWTO (R_386_GNU_VTINHERIT, /* type */
156 0, /* rightshift */
157 2, /* size (0 = byte, 1 = short, 2 = long) */
158 0, /* bitsize */
159 FALSE, /* pc_relative */
160 0, /* bitpos */
161 complain_overflow_dont, /* complain_on_overflow */
162 NULL, /* special_function */
163 "R_386_GNU_VTINHERIT", /* name */
164 FALSE, /* partial_inplace */
165 0, /* src_mask */
166 0, /* dst_mask */
167 FALSE), /* pcrel_offset */
168
169 /* GNU extension to record C++ vtable member usage. */
170 HOWTO (R_386_GNU_VTENTRY, /* type */
171 0, /* rightshift */
172 2, /* size (0 = byte, 1 = short, 2 = long) */
173 0, /* bitsize */
174 FALSE, /* pc_relative */
175 0, /* bitpos */
176 complain_overflow_dont, /* complain_on_overflow */
177 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
178 "R_386_GNU_VTENTRY", /* name */
179 FALSE, /* partial_inplace */
180 0, /* src_mask */
181 0, /* dst_mask */
182 FALSE) /* pcrel_offset */
183
184 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
185
186 };
187
188 #ifdef DEBUG_GEN_RELOC
189 #define TRACE(str) \
190 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
191 #else
192 #define TRACE(str)
193 #endif
194
195 static reloc_howto_type *
196 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
197 bfd_reloc_code_real_type code)
198 {
199 switch (code)
200 {
201 case BFD_RELOC_NONE:
202 TRACE ("BFD_RELOC_NONE");
203 return &elf_howto_table[R_386_NONE];
204
205 case BFD_RELOC_32:
206 TRACE ("BFD_RELOC_32");
207 return &elf_howto_table[R_386_32];
208
209 case BFD_RELOC_CTOR:
210 TRACE ("BFD_RELOC_CTOR");
211 return &elf_howto_table[R_386_32];
212
213 case BFD_RELOC_32_PCREL:
214 TRACE ("BFD_RELOC_PC32");
215 return &elf_howto_table[R_386_PC32];
216
217 case BFD_RELOC_386_GOT32:
218 TRACE ("BFD_RELOC_386_GOT32");
219 return &elf_howto_table[R_386_GOT32];
220
221 case BFD_RELOC_386_PLT32:
222 TRACE ("BFD_RELOC_386_PLT32");
223 return &elf_howto_table[R_386_PLT32];
224
225 case BFD_RELOC_386_COPY:
226 TRACE ("BFD_RELOC_386_COPY");
227 return &elf_howto_table[R_386_COPY];
228
229 case BFD_RELOC_386_GLOB_DAT:
230 TRACE ("BFD_RELOC_386_GLOB_DAT");
231 return &elf_howto_table[R_386_GLOB_DAT];
232
233 case BFD_RELOC_386_JUMP_SLOT:
234 TRACE ("BFD_RELOC_386_JUMP_SLOT");
235 return &elf_howto_table[R_386_JUMP_SLOT];
236
237 case BFD_RELOC_386_RELATIVE:
238 TRACE ("BFD_RELOC_386_RELATIVE");
239 return &elf_howto_table[R_386_RELATIVE];
240
241 case BFD_RELOC_386_GOTOFF:
242 TRACE ("BFD_RELOC_386_GOTOFF");
243 return &elf_howto_table[R_386_GOTOFF];
244
245 case BFD_RELOC_386_GOTPC:
246 TRACE ("BFD_RELOC_386_GOTPC");
247 return &elf_howto_table[R_386_GOTPC];
248
249 /* These relocs are a GNU extension. */
250 case BFD_RELOC_386_TLS_TPOFF:
251 TRACE ("BFD_RELOC_386_TLS_TPOFF");
252 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
253
254 case BFD_RELOC_386_TLS_IE:
255 TRACE ("BFD_RELOC_386_TLS_IE");
256 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
257
258 case BFD_RELOC_386_TLS_GOTIE:
259 TRACE ("BFD_RELOC_386_TLS_GOTIE");
260 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
261
262 case BFD_RELOC_386_TLS_LE:
263 TRACE ("BFD_RELOC_386_TLS_LE");
264 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
265
266 case BFD_RELOC_386_TLS_GD:
267 TRACE ("BFD_RELOC_386_TLS_GD");
268 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
269
270 case BFD_RELOC_386_TLS_LDM:
271 TRACE ("BFD_RELOC_386_TLS_LDM");
272 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
273
274 case BFD_RELOC_16:
275 TRACE ("BFD_RELOC_16");
276 return &elf_howto_table[R_386_16 - R_386_ext_offset];
277
278 case BFD_RELOC_16_PCREL:
279 TRACE ("BFD_RELOC_16_PCREL");
280 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
281
282 case BFD_RELOC_8:
283 TRACE ("BFD_RELOC_8");
284 return &elf_howto_table[R_386_8 - R_386_ext_offset];
285
286 case BFD_RELOC_8_PCREL:
287 TRACE ("BFD_RELOC_8_PCREL");
288 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
289
290 /* Common with Sun TLS implementation. */
291 case BFD_RELOC_386_TLS_LDO_32:
292 TRACE ("BFD_RELOC_386_TLS_LDO_32");
293 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
294
295 case BFD_RELOC_386_TLS_IE_32:
296 TRACE ("BFD_RELOC_386_TLS_IE_32");
297 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
298
299 case BFD_RELOC_386_TLS_LE_32:
300 TRACE ("BFD_RELOC_386_TLS_LE_32");
301 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
302
303 case BFD_RELOC_386_TLS_DTPMOD32:
304 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
305 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
306
307 case BFD_RELOC_386_TLS_DTPOFF32:
308 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
309 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
310
311 case BFD_RELOC_386_TLS_TPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
313 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
314
315 case BFD_RELOC_386_TLS_GOTDESC:
316 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
317 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
318
319 case BFD_RELOC_386_TLS_DESC_CALL:
320 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
321 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
322
323 case BFD_RELOC_386_TLS_DESC:
324 TRACE ("BFD_RELOC_386_TLS_DESC");
325 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
326
327 case BFD_RELOC_386_IRELATIVE:
328 TRACE ("BFD_RELOC_386_IRELATIVE");
329 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
330
331 case BFD_RELOC_VTABLE_INHERIT:
332 TRACE ("BFD_RELOC_VTABLE_INHERIT");
333 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
334
335 case BFD_RELOC_VTABLE_ENTRY:
336 TRACE ("BFD_RELOC_VTABLE_ENTRY");
337 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
338
339 default:
340 break;
341 }
342
343 TRACE ("Unknown");
344 return 0;
345 }
346
347 static reloc_howto_type *
348 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
349 const char *r_name)
350 {
351 unsigned int i;
352
353 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
354 if (elf_howto_table[i].name != NULL
355 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
356 return &elf_howto_table[i];
357
358 return NULL;
359 }
360
361 static reloc_howto_type *
362 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
363 {
364 unsigned int indx;
365
366 if ((indx = r_type) >= R_386_standard
367 && ((indx = r_type - R_386_ext_offset) - R_386_standard
368 >= R_386_ext - R_386_standard)
369 && ((indx = r_type - R_386_tls_offset) - R_386_ext
370 >= R_386_irelative - R_386_ext)
371 && ((indx = r_type - R_386_vt_offset) - R_386_irelative
372 >= R_386_vt - R_386_irelative))
373 {
374 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
375 abfd, (int) r_type);
376 indx = R_386_NONE;
377 }
378 BFD_ASSERT (elf_howto_table [indx].type == r_type);
379 return &elf_howto_table[indx];
380 }
381
382 static void
383 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
384 arelent *cache_ptr,
385 Elf_Internal_Rela *dst)
386 {
387 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
388 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
389 }
390
391 /* Return whether a symbol name implies a local label. The UnixWare
392 2.1 cc generates temporary symbols that start with .X, so we
393 recognize them here. FIXME: do other SVR4 compilers also use .X?.
394 If so, we should move the .X recognition into
395 _bfd_elf_is_local_label_name. */
396
397 static bfd_boolean
398 elf_i386_is_local_label_name (bfd *abfd, const char *name)
399 {
400 if (name[0] == '.' && name[1] == 'X')
401 return TRUE;
402
403 return _bfd_elf_is_local_label_name (abfd, name);
404 }
405 \f
406 /* Support for core dump NOTE sections. */
407
408 static bfd_boolean
409 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
410 {
411 int offset;
412 size_t size;
413
414 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
415 {
416 int pr_version = bfd_get_32 (abfd, note->descdata);
417
418 if (pr_version != 1)
419 return FALSE;
420
421 /* pr_cursig */
422 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
423
424 /* pr_pid */
425 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
426
427 /* pr_reg */
428 offset = 28;
429 size = bfd_get_32 (abfd, note->descdata + 8);
430 }
431 else
432 {
433 switch (note->descsz)
434 {
435 default:
436 return FALSE;
437
438 case 144: /* Linux/i386 */
439 /* pr_cursig */
440 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
441
442 /* pr_pid */
443 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
444
445 /* pr_reg */
446 offset = 72;
447 size = 68;
448
449 break;
450 }
451 }
452
453 /* Make a ".reg/999" section. */
454 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
455 size, note->descpos + offset);
456 }
457
458 static bfd_boolean
459 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
460 {
461 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
462 {
463 int pr_version = bfd_get_32 (abfd, note->descdata);
464
465 if (pr_version != 1)
466 return FALSE;
467
468 elf_tdata (abfd)->core_program
469 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
470 elf_tdata (abfd)->core_command
471 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
472 }
473 else
474 {
475 switch (note->descsz)
476 {
477 default:
478 return FALSE;
479
480 case 124: /* Linux/i386 elf_prpsinfo. */
481 elf_tdata (abfd)->core_pid
482 = bfd_get_32 (abfd, note->descdata + 12);
483 elf_tdata (abfd)->core_program
484 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
485 elf_tdata (abfd)->core_command
486 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
487 }
488 }
489
490 /* Note that for some reason, a spurious space is tacked
491 onto the end of the args in some (at least one anyway)
492 implementations, so strip it off if it exists. */
493 {
494 char *command = elf_tdata (abfd)->core_command;
495 int n = strlen (command);
496
497 if (0 < n && command[n - 1] == ' ')
498 command[n - 1] = '\0';
499 }
500
501 return TRUE;
502 }
503 \f
504 /* Functions for the i386 ELF linker.
505
506 In order to gain some understanding of code in this file without
507 knowing all the intricate details of the linker, note the
508 following:
509
510 Functions named elf_i386_* are called by external routines, other
511 functions are only called locally. elf_i386_* functions appear
512 in this file more or less in the order in which they are called
513 from external routines. eg. elf_i386_check_relocs is called
514 early in the link process, elf_i386_finish_dynamic_sections is
515 one of the last functions. */
516
517
518 /* The name of the dynamic interpreter. This is put in the .interp
519 section. */
520
521 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
522
523 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
524 copying dynamic variables from a shared lib into an app's dynbss
525 section, and instead use a dynamic relocation to point into the
526 shared lib. */
527 #define ELIMINATE_COPY_RELOCS 1
528
529 /* The size in bytes of an entry in the procedure linkage table. */
530
531 #define PLT_ENTRY_SIZE 16
532
533 /* The first entry in an absolute procedure linkage table looks like
534 this. See the SVR4 ABI i386 supplement to see how this works.
535 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
536
537 static const bfd_byte elf_i386_plt0_entry[12] =
538 {
539 0xff, 0x35, /* pushl contents of address */
540 0, 0, 0, 0, /* replaced with address of .got + 4. */
541 0xff, 0x25, /* jmp indirect */
542 0, 0, 0, 0 /* replaced with address of .got + 8. */
543 };
544
545 /* Subsequent entries in an absolute procedure linkage table look like
546 this. */
547
548 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
549 {
550 0xff, 0x25, /* jmp indirect */
551 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
552 0x68, /* pushl immediate */
553 0, 0, 0, 0, /* replaced with offset into relocation table. */
554 0xe9, /* jmp relative */
555 0, 0, 0, 0 /* replaced with offset to start of .plt. */
556 };
557
558 /* The first entry in a PIC procedure linkage table look like this.
559 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
560
561 static const bfd_byte elf_i386_pic_plt0_entry[12] =
562 {
563 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
564 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
565 };
566
567 /* Subsequent entries in a PIC procedure linkage table look like this. */
568
569 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
570 {
571 0xff, 0xa3, /* jmp *offset(%ebx) */
572 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
573 0x68, /* pushl immediate */
574 0, 0, 0, 0, /* replaced with offset into relocation table. */
575 0xe9, /* jmp relative */
576 0, 0, 0, 0 /* replaced with offset to start of .plt. */
577 };
578
579 /* .eh_frame covering the .plt section. */
580
581 static const bfd_byte elf_i386_eh_frame_plt[] =
582 {
583 #define PLT_CIE_LENGTH 20
584 #define PLT_FDE_LENGTH 36
585 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
586 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
587 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
588 0, 0, 0, 0, /* CIE ID */
589 1, /* CIE version */
590 'z', 'R', 0, /* Augmentation string */
591 1, /* Code alignment factor */
592 0x7c, /* Data alignment factor */
593 8, /* Return address column */
594 1, /* Augmentation size */
595 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
596 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
597 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
598 DW_CFA_nop, DW_CFA_nop,
599
600 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
601 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
602 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
603 0, 0, 0, 0, /* .plt size goes here */
604 0, /* Augmentation size */
605 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
606 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
607 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
608 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
609 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
610 11, /* Block length */
611 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
612 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
613 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
614 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
615 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
616 };
617
618 struct elf_i386_plt_layout
619 {
620 /* The first entry in an absolute procedure linkage table looks like this. */
621 const bfd_byte *plt0_entry;
622 unsigned int plt0_entry_size;
623
624 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
625 unsigned int plt0_got1_offset;
626 unsigned int plt0_got2_offset;
627
628 /* Later entries in an absolute procedure linkage table look like this. */
629 const bfd_byte *plt_entry;
630 unsigned int plt_entry_size;
631
632 /* Offsets into plt_entry that are to be replaced with... */
633 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
634 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
635 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
636
637 /* Offset into plt_entry where the initial value of the GOT entry points. */
638 unsigned int plt_lazy_offset;
639
640 /* The first entry in a PIC procedure linkage table looks like this. */
641 const bfd_byte *pic_plt0_entry;
642
643 /* Subsequent entries in a PIC procedure linkage table look like this. */
644 const bfd_byte *pic_plt_entry;
645
646 /* .eh_frame covering the .plt section. */
647 const bfd_byte *eh_frame_plt;
648 unsigned int eh_frame_plt_size;
649 };
650
651 #define GET_PLT_ENTRY_SIZE(abfd) \
652 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
653
654 /* These are the standard parameters. */
655 static const struct elf_i386_plt_layout elf_i386_plt =
656 {
657 elf_i386_plt0_entry, /* plt0_entry */
658 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
659 2, /* plt0_got1_offset */
660 8, /* plt0_got2_offset */
661 elf_i386_plt_entry, /* plt_entry */
662 PLT_ENTRY_SIZE, /* plt_entry_size */
663 2, /* plt_got_offset */
664 7, /* plt_reloc_offset */
665 12, /* plt_plt_offset */
666 6, /* plt_lazy_offset */
667 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
668 elf_i386_pic_plt_entry, /* pic_plt_entry */
669 elf_i386_eh_frame_plt, /* eh_frame_plt */
670 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
671 };
672 \f
673
674 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
675 for the PLTResolve stub and then for each PLT entry. */
676 #define PLTRESOLVE_RELOCS_SHLIB 0
677 #define PLTRESOLVE_RELOCS 2
678 #define PLT_NON_JUMP_SLOT_RELOCS 2
679
680 /* Architecture-specific backend data for i386. */
681
682 struct elf_i386_backend_data
683 {
684 /* Parameters describing PLT generation. */
685 const struct elf_i386_plt_layout *plt;
686
687 /* Value used to fill the unused bytes of the first PLT entry. */
688 bfd_byte plt0_pad_byte;
689
690 /* True if the target system is VxWorks. */
691 int is_vxworks;
692 };
693
694 #define get_elf_i386_backend_data(abfd) \
695 ((const struct elf_i386_backend_data *) \
696 get_elf_backend_data (abfd)->arch_data)
697
698 /* These are the standard parameters. */
699 static const struct elf_i386_backend_data elf_i386_arch_bed =
700 {
701 &elf_i386_plt, /* plt */
702 0, /* plt0_pad_byte */
703 0, /* is_vxworks */
704 };
705
706 #define elf_backend_arch_data &elf_i386_arch_bed
707
708 /* i386 ELF linker hash entry. */
709
710 struct elf_i386_link_hash_entry
711 {
712 struct elf_link_hash_entry elf;
713
714 /* Track dynamic relocs copied for this symbol. */
715 struct elf_dyn_relocs *dyn_relocs;
716
717 #define GOT_UNKNOWN 0
718 #define GOT_NORMAL 1
719 #define GOT_TLS_GD 2
720 #define GOT_TLS_IE 4
721 #define GOT_TLS_IE_POS 5
722 #define GOT_TLS_IE_NEG 6
723 #define GOT_TLS_IE_BOTH 7
724 #define GOT_TLS_GDESC 8
725 #define GOT_TLS_GD_BOTH_P(type) \
726 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
727 #define GOT_TLS_GD_P(type) \
728 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
729 #define GOT_TLS_GDESC_P(type) \
730 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
731 #define GOT_TLS_GD_ANY_P(type) \
732 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
733 unsigned char tls_type;
734
735 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
736 starting at the end of the jump table. */
737 bfd_vma tlsdesc_got;
738 };
739
740 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
741
742 struct elf_i386_obj_tdata
743 {
744 struct elf_obj_tdata root;
745
746 /* tls_type for each local got entry. */
747 char *local_got_tls_type;
748
749 /* GOTPLT entries for TLS descriptors. */
750 bfd_vma *local_tlsdesc_gotent;
751 };
752
753 #define elf_i386_tdata(abfd) \
754 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
755
756 #define elf_i386_local_got_tls_type(abfd) \
757 (elf_i386_tdata (abfd)->local_got_tls_type)
758
759 #define elf_i386_local_tlsdesc_gotent(abfd) \
760 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
761
762 #define is_i386_elf(bfd) \
763 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
764 && elf_tdata (bfd) != NULL \
765 && elf_object_id (bfd) == I386_ELF_DATA)
766
767 static bfd_boolean
768 elf_i386_mkobject (bfd *abfd)
769 {
770 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
771 I386_ELF_DATA);
772 }
773
774 /* i386 ELF linker hash table. */
775
776 struct elf_i386_link_hash_table
777 {
778 struct elf_link_hash_table elf;
779
780 /* Short-cuts to get to dynamic linker sections. */
781 asection *sdynbss;
782 asection *srelbss;
783 asection *plt_eh_frame;
784
785 union
786 {
787 bfd_signed_vma refcount;
788 bfd_vma offset;
789 } tls_ldm_got;
790
791 /* The amount of space used by the reserved portion of the sgotplt
792 section, plus whatever space is used by the jump slots. */
793 bfd_vma sgotplt_jump_table_size;
794
795 /* Small local sym cache. */
796 struct sym_cache sym_cache;
797
798 /* _TLS_MODULE_BASE_ symbol. */
799 struct bfd_link_hash_entry *tls_module_base;
800
801 /* Used by local STT_GNU_IFUNC symbols. */
802 htab_t loc_hash_table;
803 void * loc_hash_memory;
804
805 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
806 asection *srelplt2;
807
808 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
809 bfd_vma next_tls_desc_index;
810
811 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
812 bfd_vma next_jump_slot_index;
813
814 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
815 bfd_vma next_irelative_index;
816 };
817
818 /* Get the i386 ELF linker hash table from a link_info structure. */
819
820 #define elf_i386_hash_table(p) \
821 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
822 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
823
824 #define elf_i386_compute_jump_table_size(htab) \
825 ((htab)->next_tls_desc_index * 4)
826
827 /* Create an entry in an i386 ELF linker hash table. */
828
829 static struct bfd_hash_entry *
830 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
831 struct bfd_hash_table *table,
832 const char *string)
833 {
834 /* Allocate the structure if it has not already been allocated by a
835 subclass. */
836 if (entry == NULL)
837 {
838 entry = (struct bfd_hash_entry *)
839 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
840 if (entry == NULL)
841 return entry;
842 }
843
844 /* Call the allocation method of the superclass. */
845 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
846 if (entry != NULL)
847 {
848 struct elf_i386_link_hash_entry *eh;
849
850 eh = (struct elf_i386_link_hash_entry *) entry;
851 eh->dyn_relocs = NULL;
852 eh->tls_type = GOT_UNKNOWN;
853 eh->tlsdesc_got = (bfd_vma) -1;
854 }
855
856 return entry;
857 }
858
859 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
860 for local symbol so that we can handle local STT_GNU_IFUNC symbols
861 as global symbol. We reuse indx and dynstr_index for local symbol
862 hash since they aren't used by global symbols in this backend. */
863
864 static hashval_t
865 elf_i386_local_htab_hash (const void *ptr)
866 {
867 struct elf_link_hash_entry *h
868 = (struct elf_link_hash_entry *) ptr;
869 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
870 }
871
872 /* Compare local hash entries. */
873
874 static int
875 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
876 {
877 struct elf_link_hash_entry *h1
878 = (struct elf_link_hash_entry *) ptr1;
879 struct elf_link_hash_entry *h2
880 = (struct elf_link_hash_entry *) ptr2;
881
882 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
883 }
884
885 /* Find and/or create a hash entry for local symbol. */
886
887 static struct elf_link_hash_entry *
888 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
889 bfd *abfd, const Elf_Internal_Rela *rel,
890 bfd_boolean create)
891 {
892 struct elf_i386_link_hash_entry e, *ret;
893 asection *sec = abfd->sections;
894 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
895 ELF32_R_SYM (rel->r_info));
896 void **slot;
897
898 e.elf.indx = sec->id;
899 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
900 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
901 create ? INSERT : NO_INSERT);
902
903 if (!slot)
904 return NULL;
905
906 if (*slot)
907 {
908 ret = (struct elf_i386_link_hash_entry *) *slot;
909 return &ret->elf;
910 }
911
912 ret = (struct elf_i386_link_hash_entry *)
913 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
914 sizeof (struct elf_i386_link_hash_entry));
915 if (ret)
916 {
917 memset (ret, 0, sizeof (*ret));
918 ret->elf.indx = sec->id;
919 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
920 ret->elf.dynindx = -1;
921 *slot = ret;
922 }
923 return &ret->elf;
924 }
925
926 /* Create an i386 ELF linker hash table. */
927
928 static struct bfd_link_hash_table *
929 elf_i386_link_hash_table_create (bfd *abfd)
930 {
931 struct elf_i386_link_hash_table *ret;
932 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
933
934 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
935 if (ret == NULL)
936 return NULL;
937
938 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
939 elf_i386_link_hash_newfunc,
940 sizeof (struct elf_i386_link_hash_entry),
941 I386_ELF_DATA))
942 {
943 free (ret);
944 return NULL;
945 }
946
947 ret->sdynbss = NULL;
948 ret->srelbss = NULL;
949 ret->plt_eh_frame = NULL;
950 ret->tls_ldm_got.refcount = 0;
951 ret->next_tls_desc_index = 0;
952 ret->sgotplt_jump_table_size = 0;
953 ret->sym_cache.abfd = NULL;
954 ret->srelplt2 = NULL;
955 ret->tls_module_base = NULL;
956 ret->next_jump_slot_index = 0;
957 ret->next_irelative_index = 0;
958
959 ret->loc_hash_table = htab_try_create (1024,
960 elf_i386_local_htab_hash,
961 elf_i386_local_htab_eq,
962 NULL);
963 ret->loc_hash_memory = objalloc_create ();
964 if (!ret->loc_hash_table || !ret->loc_hash_memory)
965 {
966 free (ret);
967 return NULL;
968 }
969
970 return &ret->elf.root;
971 }
972
973 /* Destroy an i386 ELF linker hash table. */
974
975 static void
976 elf_i386_link_hash_table_free (struct bfd_link_hash_table *hash)
977 {
978 struct elf_i386_link_hash_table *htab
979 = (struct elf_i386_link_hash_table *) hash;
980
981 if (htab->loc_hash_table)
982 htab_delete (htab->loc_hash_table);
983 if (htab->loc_hash_memory)
984 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
985 _bfd_generic_link_hash_table_free (hash);
986 }
987
988 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
989 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
990 hash table. */
991
992 static bfd_boolean
993 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
994 {
995 struct elf_i386_link_hash_table *htab;
996
997 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
998 return FALSE;
999
1000 htab = elf_i386_hash_table (info);
1001 if (htab == NULL)
1002 return FALSE;
1003
1004 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1005 if (!info->shared)
1006 htab->srelbss = bfd_get_linker_section (dynobj, ".rel.bss");
1007
1008 if (!htab->sdynbss
1009 || (!info->shared && !htab->srelbss))
1010 abort ();
1011
1012 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1013 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1014 &htab->srelplt2))
1015 return FALSE;
1016
1017 if (!info->no_ld_generated_unwind_info
1018 && htab->plt_eh_frame == NULL
1019 && htab->elf.splt != NULL)
1020 {
1021 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1022 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1023 | SEC_LINKER_CREATED);
1024 htab->plt_eh_frame
1025 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1026 if (htab->plt_eh_frame == NULL
1027 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1028 return FALSE;
1029 }
1030
1031 return TRUE;
1032 }
1033
1034 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1035
1036 static void
1037 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1038 struct elf_link_hash_entry *dir,
1039 struct elf_link_hash_entry *ind)
1040 {
1041 struct elf_i386_link_hash_entry *edir, *eind;
1042
1043 edir = (struct elf_i386_link_hash_entry *) dir;
1044 eind = (struct elf_i386_link_hash_entry *) ind;
1045
1046 if (eind->dyn_relocs != NULL)
1047 {
1048 if (edir->dyn_relocs != NULL)
1049 {
1050 struct elf_dyn_relocs **pp;
1051 struct elf_dyn_relocs *p;
1052
1053 /* Add reloc counts against the indirect sym to the direct sym
1054 list. Merge any entries against the same section. */
1055 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1056 {
1057 struct elf_dyn_relocs *q;
1058
1059 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1060 if (q->sec == p->sec)
1061 {
1062 q->pc_count += p->pc_count;
1063 q->count += p->count;
1064 *pp = p->next;
1065 break;
1066 }
1067 if (q == NULL)
1068 pp = &p->next;
1069 }
1070 *pp = edir->dyn_relocs;
1071 }
1072
1073 edir->dyn_relocs = eind->dyn_relocs;
1074 eind->dyn_relocs = NULL;
1075 }
1076
1077 if (ind->root.type == bfd_link_hash_indirect
1078 && dir->got.refcount <= 0)
1079 {
1080 edir->tls_type = eind->tls_type;
1081 eind->tls_type = GOT_UNKNOWN;
1082 }
1083
1084 if (ELIMINATE_COPY_RELOCS
1085 && ind->root.type != bfd_link_hash_indirect
1086 && dir->dynamic_adjusted)
1087 {
1088 /* If called to transfer flags for a weakdef during processing
1089 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1090 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1091 dir->ref_dynamic |= ind->ref_dynamic;
1092 dir->ref_regular |= ind->ref_regular;
1093 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1094 dir->needs_plt |= ind->needs_plt;
1095 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1096 }
1097 else
1098 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1099 }
1100
1101 /* Return TRUE if the TLS access code sequence support transition
1102 from R_TYPE. */
1103
1104 static bfd_boolean
1105 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1106 bfd_byte *contents,
1107 Elf_Internal_Shdr *symtab_hdr,
1108 struct elf_link_hash_entry **sym_hashes,
1109 unsigned int r_type,
1110 const Elf_Internal_Rela *rel,
1111 const Elf_Internal_Rela *relend)
1112 {
1113 unsigned int val, type;
1114 unsigned long r_symndx;
1115 struct elf_link_hash_entry *h;
1116 bfd_vma offset;
1117
1118 /* Get the section contents. */
1119 if (contents == NULL)
1120 {
1121 if (elf_section_data (sec)->this_hdr.contents != NULL)
1122 contents = elf_section_data (sec)->this_hdr.contents;
1123 else
1124 {
1125 /* FIXME: How to better handle error condition? */
1126 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1127 return FALSE;
1128
1129 /* Cache the section contents for elf_link_input_bfd. */
1130 elf_section_data (sec)->this_hdr.contents = contents;
1131 }
1132 }
1133
1134 offset = rel->r_offset;
1135 switch (r_type)
1136 {
1137 case R_386_TLS_GD:
1138 case R_386_TLS_LDM:
1139 if (offset < 2 || (rel + 1) >= relend)
1140 return FALSE;
1141
1142 type = bfd_get_8 (abfd, contents + offset - 2);
1143 if (r_type == R_386_TLS_GD)
1144 {
1145 /* Check transition from GD access model. Only
1146 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1147 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1148 can transit to different access model. */
1149 if ((offset + 10) > sec->size ||
1150 (type != 0x8d && type != 0x04))
1151 return FALSE;
1152
1153 val = bfd_get_8 (abfd, contents + offset - 1);
1154 if (type == 0x04)
1155 {
1156 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1157 if (offset < 3)
1158 return FALSE;
1159
1160 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1161 return FALSE;
1162
1163 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1164 return FALSE;
1165 }
1166 else
1167 {
1168 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1169 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1170 return FALSE;
1171
1172 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1173 return FALSE;
1174 }
1175 }
1176 else
1177 {
1178 /* Check transition from LD access model. Only
1179 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1180 can transit to different access model. */
1181 if (type != 0x8d || (offset + 9) > sec->size)
1182 return FALSE;
1183
1184 val = bfd_get_8 (abfd, contents + offset - 1);
1185 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1186 return FALSE;
1187 }
1188
1189 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1190 return FALSE;
1191
1192 r_symndx = ELF32_R_SYM (rel[1].r_info);
1193 if (r_symndx < symtab_hdr->sh_info)
1194 return FALSE;
1195
1196 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1197 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1198 may be versioned. */
1199 return (h != NULL
1200 && h->root.root.string != NULL
1201 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1202 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1203 && (strncmp (h->root.root.string, "___tls_get_addr",
1204 15) == 0));
1205
1206 case R_386_TLS_IE:
1207 /* Check transition from IE access model:
1208 movl foo@indntpoff(%rip), %eax
1209 movl foo@indntpoff(%rip), %reg
1210 addl foo@indntpoff(%rip), %reg
1211 */
1212
1213 if (offset < 1 || (offset + 4) > sec->size)
1214 return FALSE;
1215
1216 /* Check "movl foo@tpoff(%rip), %eax" first. */
1217 val = bfd_get_8 (abfd, contents + offset - 1);
1218 if (val == 0xa1)
1219 return TRUE;
1220
1221 if (offset < 2)
1222 return FALSE;
1223
1224 /* Check movl|addl foo@tpoff(%rip), %reg. */
1225 type = bfd_get_8 (abfd, contents + offset - 2);
1226 return ((type == 0x8b || type == 0x03)
1227 && (val & 0xc7) == 0x05);
1228
1229 case R_386_TLS_GOTIE:
1230 case R_386_TLS_IE_32:
1231 /* Check transition from {IE_32,GOTIE} access model:
1232 subl foo@{tpoff,gontoff}(%reg1), %reg2
1233 movl foo@{tpoff,gontoff}(%reg1), %reg2
1234 addl foo@{tpoff,gontoff}(%reg1), %reg2
1235 */
1236
1237 if (offset < 2 || (offset + 4) > sec->size)
1238 return FALSE;
1239
1240 val = bfd_get_8 (abfd, contents + offset - 1);
1241 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1242 return FALSE;
1243
1244 type = bfd_get_8 (abfd, contents + offset - 2);
1245 return type == 0x8b || type == 0x2b || type == 0x03;
1246
1247 case R_386_TLS_GOTDESC:
1248 /* Check transition from GDesc access model:
1249 leal x@tlsdesc(%ebx), %eax
1250
1251 Make sure it's a leal adding ebx to a 32-bit offset
1252 into any register, although it's probably almost always
1253 going to be eax. */
1254
1255 if (offset < 2 || (offset + 4) > sec->size)
1256 return FALSE;
1257
1258 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1259 return FALSE;
1260
1261 val = bfd_get_8 (abfd, contents + offset - 1);
1262 return (val & 0xc7) == 0x83;
1263
1264 case R_386_TLS_DESC_CALL:
1265 /* Check transition from GDesc access model:
1266 call *x@tlsdesc(%rax)
1267 */
1268 if (offset + 2 <= sec->size)
1269 {
1270 /* Make sure that it's a call *x@tlsdesc(%rax). */
1271 static const unsigned char call[] = { 0xff, 0x10 };
1272 return memcmp (contents + offset, call, 2) == 0;
1273 }
1274
1275 return FALSE;
1276
1277 default:
1278 abort ();
1279 }
1280 }
1281
1282 /* Return TRUE if the TLS access transition is OK or no transition
1283 will be performed. Update R_TYPE if there is a transition. */
1284
1285 static bfd_boolean
1286 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1287 asection *sec, bfd_byte *contents,
1288 Elf_Internal_Shdr *symtab_hdr,
1289 struct elf_link_hash_entry **sym_hashes,
1290 unsigned int *r_type, int tls_type,
1291 const Elf_Internal_Rela *rel,
1292 const Elf_Internal_Rela *relend,
1293 struct elf_link_hash_entry *h,
1294 unsigned long r_symndx)
1295 {
1296 unsigned int from_type = *r_type;
1297 unsigned int to_type = from_type;
1298 bfd_boolean check = TRUE;
1299
1300 /* Skip TLS transition for functions. */
1301 if (h != NULL
1302 && (h->type == STT_FUNC
1303 || h->type == STT_GNU_IFUNC))
1304 return TRUE;
1305
1306 switch (from_type)
1307 {
1308 case R_386_TLS_GD:
1309 case R_386_TLS_GOTDESC:
1310 case R_386_TLS_DESC_CALL:
1311 case R_386_TLS_IE_32:
1312 case R_386_TLS_IE:
1313 case R_386_TLS_GOTIE:
1314 if (info->executable)
1315 {
1316 if (h == NULL)
1317 to_type = R_386_TLS_LE_32;
1318 else if (from_type != R_386_TLS_IE
1319 && from_type != R_386_TLS_GOTIE)
1320 to_type = R_386_TLS_IE_32;
1321 }
1322
1323 /* When we are called from elf_i386_relocate_section, CONTENTS
1324 isn't NULL and there may be additional transitions based on
1325 TLS_TYPE. */
1326 if (contents != NULL)
1327 {
1328 unsigned int new_to_type = to_type;
1329
1330 if (info->executable
1331 && h != NULL
1332 && h->dynindx == -1
1333 && (tls_type & GOT_TLS_IE))
1334 new_to_type = R_386_TLS_LE_32;
1335
1336 if (to_type == R_386_TLS_GD
1337 || to_type == R_386_TLS_GOTDESC
1338 || to_type == R_386_TLS_DESC_CALL)
1339 {
1340 if (tls_type == GOT_TLS_IE_POS)
1341 new_to_type = R_386_TLS_GOTIE;
1342 else if (tls_type & GOT_TLS_IE)
1343 new_to_type = R_386_TLS_IE_32;
1344 }
1345
1346 /* We checked the transition before when we were called from
1347 elf_i386_check_relocs. We only want to check the new
1348 transition which hasn't been checked before. */
1349 check = new_to_type != to_type && from_type == to_type;
1350 to_type = new_to_type;
1351 }
1352
1353 break;
1354
1355 case R_386_TLS_LDM:
1356 if (info->executable)
1357 to_type = R_386_TLS_LE_32;
1358 break;
1359
1360 default:
1361 return TRUE;
1362 }
1363
1364 /* Return TRUE if there is no transition. */
1365 if (from_type == to_type)
1366 return TRUE;
1367
1368 /* Check if the transition can be performed. */
1369 if (check
1370 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1371 symtab_hdr, sym_hashes,
1372 from_type, rel, relend))
1373 {
1374 reloc_howto_type *from, *to;
1375 const char *name;
1376
1377 from = elf_i386_rtype_to_howto (abfd, from_type);
1378 to = elf_i386_rtype_to_howto (abfd, to_type);
1379
1380 if (h)
1381 name = h->root.root.string;
1382 else
1383 {
1384 struct elf_i386_link_hash_table *htab;
1385
1386 htab = elf_i386_hash_table (info);
1387 if (htab == NULL)
1388 name = "*unknown*";
1389 else
1390 {
1391 Elf_Internal_Sym *isym;
1392
1393 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1394 abfd, r_symndx);
1395 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1396 }
1397 }
1398
1399 (*_bfd_error_handler)
1400 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1401 "in section `%A' failed"),
1402 abfd, sec, from->name, to->name, name,
1403 (unsigned long) rel->r_offset);
1404 bfd_set_error (bfd_error_bad_value);
1405 return FALSE;
1406 }
1407
1408 *r_type = to_type;
1409 return TRUE;
1410 }
1411
1412 /* Look through the relocs for a section during the first phase, and
1413 calculate needed space in the global offset table, procedure linkage
1414 table, and dynamic reloc sections. */
1415
1416 static bfd_boolean
1417 elf_i386_check_relocs (bfd *abfd,
1418 struct bfd_link_info *info,
1419 asection *sec,
1420 const Elf_Internal_Rela *relocs)
1421 {
1422 struct elf_i386_link_hash_table *htab;
1423 Elf_Internal_Shdr *symtab_hdr;
1424 struct elf_link_hash_entry **sym_hashes;
1425 const Elf_Internal_Rela *rel;
1426 const Elf_Internal_Rela *rel_end;
1427 asection *sreloc;
1428
1429 if (info->relocatable)
1430 return TRUE;
1431
1432 BFD_ASSERT (is_i386_elf (abfd));
1433
1434 htab = elf_i386_hash_table (info);
1435 if (htab == NULL)
1436 return FALSE;
1437
1438 symtab_hdr = &elf_symtab_hdr (abfd);
1439 sym_hashes = elf_sym_hashes (abfd);
1440
1441 sreloc = NULL;
1442
1443 rel_end = relocs + sec->reloc_count;
1444 for (rel = relocs; rel < rel_end; rel++)
1445 {
1446 unsigned int r_type;
1447 unsigned long r_symndx;
1448 struct elf_link_hash_entry *h;
1449 Elf_Internal_Sym *isym;
1450 const char *name;
1451
1452 r_symndx = ELF32_R_SYM (rel->r_info);
1453 r_type = ELF32_R_TYPE (rel->r_info);
1454
1455 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1456 {
1457 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1458 abfd,
1459 r_symndx);
1460 return FALSE;
1461 }
1462
1463 if (r_symndx < symtab_hdr->sh_info)
1464 {
1465 /* A local symbol. */
1466 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1467 abfd, r_symndx);
1468 if (isym == NULL)
1469 return FALSE;
1470
1471 /* Check relocation against local STT_GNU_IFUNC symbol. */
1472 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1473 {
1474 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1475 if (h == NULL)
1476 return FALSE;
1477
1478 /* Fake a STT_GNU_IFUNC symbol. */
1479 h->type = STT_GNU_IFUNC;
1480 h->def_regular = 1;
1481 h->ref_regular = 1;
1482 h->forced_local = 1;
1483 h->root.type = bfd_link_hash_defined;
1484 }
1485 else
1486 h = NULL;
1487 }
1488 else
1489 {
1490 isym = NULL;
1491 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1492 while (h->root.type == bfd_link_hash_indirect
1493 || h->root.type == bfd_link_hash_warning)
1494 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1495 }
1496
1497 if (h != NULL)
1498 {
1499 /* Create the ifunc sections for static executables. If we
1500 never see an indirect function symbol nor we are building
1501 a static executable, those sections will be empty and
1502 won't appear in output. */
1503 switch (r_type)
1504 {
1505 default:
1506 break;
1507
1508 case R_386_32:
1509 case R_386_PC32:
1510 case R_386_PLT32:
1511 case R_386_GOT32:
1512 case R_386_GOTOFF:
1513 if (htab->elf.dynobj == NULL)
1514 htab->elf.dynobj = abfd;
1515 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1516 return FALSE;
1517 break;
1518 }
1519
1520 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1521 it here if it is defined in a non-shared object. */
1522 if (h->type == STT_GNU_IFUNC
1523 && h->def_regular)
1524 {
1525 /* It is referenced by a non-shared object. */
1526 h->ref_regular = 1;
1527 h->needs_plt = 1;
1528
1529 /* STT_GNU_IFUNC symbol must go through PLT. */
1530 h->plt.refcount += 1;
1531
1532 /* STT_GNU_IFUNC needs dynamic sections. */
1533 if (htab->elf.dynobj == NULL)
1534 htab->elf.dynobj = abfd;
1535
1536 switch (r_type)
1537 {
1538 default:
1539 if (h->root.root.string)
1540 name = h->root.root.string;
1541 else
1542 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1543 NULL);
1544 (*_bfd_error_handler)
1545 (_("%B: relocation %s against STT_GNU_IFUNC "
1546 "symbol `%s' isn't handled by %s"), abfd,
1547 elf_howto_table[r_type].name,
1548 name, __FUNCTION__);
1549 bfd_set_error (bfd_error_bad_value);
1550 return FALSE;
1551
1552 case R_386_32:
1553 h->non_got_ref = 1;
1554 h->pointer_equality_needed = 1;
1555 if (info->shared)
1556 {
1557 /* We must copy these reloc types into the
1558 output file. Create a reloc section in
1559 dynobj and make room for this reloc. */
1560 sreloc = _bfd_elf_create_ifunc_dyn_reloc
1561 (abfd, info, sec, sreloc,
1562 &((struct elf_i386_link_hash_entry *) h)->dyn_relocs);
1563 if (sreloc == NULL)
1564 return FALSE;
1565 }
1566 break;
1567
1568 case R_386_PC32:
1569 h->non_got_ref = 1;
1570 break;
1571
1572 case R_386_PLT32:
1573 break;
1574
1575 case R_386_GOT32:
1576 case R_386_GOTOFF:
1577 h->got.refcount += 1;
1578 if (htab->elf.sgot == NULL
1579 && !_bfd_elf_create_got_section (htab->elf.dynobj,
1580 info))
1581 return FALSE;
1582 break;
1583 }
1584
1585 continue;
1586 }
1587 }
1588
1589 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1590 symtab_hdr, sym_hashes,
1591 &r_type, GOT_UNKNOWN,
1592 rel, rel_end, h, r_symndx))
1593 return FALSE;
1594
1595 switch (r_type)
1596 {
1597 case R_386_TLS_LDM:
1598 htab->tls_ldm_got.refcount += 1;
1599 goto create_got;
1600
1601 case R_386_PLT32:
1602 /* This symbol requires a procedure linkage table entry. We
1603 actually build the entry in adjust_dynamic_symbol,
1604 because this might be a case of linking PIC code which is
1605 never referenced by a dynamic object, in which case we
1606 don't need to generate a procedure linkage table entry
1607 after all. */
1608
1609 /* If this is a local symbol, we resolve it directly without
1610 creating a procedure linkage table entry. */
1611 if (h == NULL)
1612 continue;
1613
1614 h->needs_plt = 1;
1615 h->plt.refcount += 1;
1616 break;
1617
1618 case R_386_TLS_IE_32:
1619 case R_386_TLS_IE:
1620 case R_386_TLS_GOTIE:
1621 if (!info->executable)
1622 info->flags |= DF_STATIC_TLS;
1623 /* Fall through */
1624
1625 case R_386_GOT32:
1626 case R_386_TLS_GD:
1627 case R_386_TLS_GOTDESC:
1628 case R_386_TLS_DESC_CALL:
1629 /* This symbol requires a global offset table entry. */
1630 {
1631 int tls_type, old_tls_type;
1632
1633 switch (r_type)
1634 {
1635 default:
1636 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1637 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1638 case R_386_TLS_GOTDESC:
1639 case R_386_TLS_DESC_CALL:
1640 tls_type = GOT_TLS_GDESC; break;
1641 case R_386_TLS_IE_32:
1642 if (ELF32_R_TYPE (rel->r_info) == r_type)
1643 tls_type = GOT_TLS_IE_NEG;
1644 else
1645 /* If this is a GD->IE transition, we may use either of
1646 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1647 tls_type = GOT_TLS_IE;
1648 break;
1649 case R_386_TLS_IE:
1650 case R_386_TLS_GOTIE:
1651 tls_type = GOT_TLS_IE_POS; break;
1652 }
1653
1654 if (h != NULL)
1655 {
1656 h->got.refcount += 1;
1657 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1658 }
1659 else
1660 {
1661 bfd_signed_vma *local_got_refcounts;
1662
1663 /* This is a global offset table entry for a local symbol. */
1664 local_got_refcounts = elf_local_got_refcounts (abfd);
1665 if (local_got_refcounts == NULL)
1666 {
1667 bfd_size_type size;
1668
1669 size = symtab_hdr->sh_info;
1670 size *= (sizeof (bfd_signed_vma)
1671 + sizeof (bfd_vma) + sizeof(char));
1672 local_got_refcounts = (bfd_signed_vma *)
1673 bfd_zalloc (abfd, size);
1674 if (local_got_refcounts == NULL)
1675 return FALSE;
1676 elf_local_got_refcounts (abfd) = local_got_refcounts;
1677 elf_i386_local_tlsdesc_gotent (abfd)
1678 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1679 elf_i386_local_got_tls_type (abfd)
1680 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1681 }
1682 local_got_refcounts[r_symndx] += 1;
1683 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1684 }
1685
1686 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1687 tls_type |= old_tls_type;
1688 /* If a TLS symbol is accessed using IE at least once,
1689 there is no point to use dynamic model for it. */
1690 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1691 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1692 || (tls_type & GOT_TLS_IE) == 0))
1693 {
1694 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1695 tls_type = old_tls_type;
1696 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1697 && GOT_TLS_GD_ANY_P (tls_type))
1698 tls_type |= old_tls_type;
1699 else
1700 {
1701 if (h)
1702 name = h->root.root.string;
1703 else
1704 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1705 NULL);
1706 (*_bfd_error_handler)
1707 (_("%B: `%s' accessed both as normal and "
1708 "thread local symbol"),
1709 abfd, name);
1710 return FALSE;
1711 }
1712 }
1713
1714 if (old_tls_type != tls_type)
1715 {
1716 if (h != NULL)
1717 elf_i386_hash_entry (h)->tls_type = tls_type;
1718 else
1719 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1720 }
1721 }
1722 /* Fall through */
1723
1724 case R_386_GOTOFF:
1725 case R_386_GOTPC:
1726 create_got:
1727 if (htab->elf.sgot == NULL)
1728 {
1729 if (htab->elf.dynobj == NULL)
1730 htab->elf.dynobj = abfd;
1731 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1732 return FALSE;
1733 }
1734 if (r_type != R_386_TLS_IE)
1735 break;
1736 /* Fall through */
1737
1738 case R_386_TLS_LE_32:
1739 case R_386_TLS_LE:
1740 if (info->executable)
1741 break;
1742 info->flags |= DF_STATIC_TLS;
1743 /* Fall through */
1744
1745 case R_386_32:
1746 case R_386_PC32:
1747 if (h != NULL && info->executable)
1748 {
1749 /* If this reloc is in a read-only section, we might
1750 need a copy reloc. We can't check reliably at this
1751 stage whether the section is read-only, as input
1752 sections have not yet been mapped to output sections.
1753 Tentatively set the flag for now, and correct in
1754 adjust_dynamic_symbol. */
1755 h->non_got_ref = 1;
1756
1757 /* We may need a .plt entry if the function this reloc
1758 refers to is in a shared lib. */
1759 h->plt.refcount += 1;
1760 if (r_type != R_386_PC32)
1761 h->pointer_equality_needed = 1;
1762 }
1763
1764 /* If we are creating a shared library, and this is a reloc
1765 against a global symbol, or a non PC relative reloc
1766 against a local symbol, then we need to copy the reloc
1767 into the shared library. However, if we are linking with
1768 -Bsymbolic, we do not need to copy a reloc against a
1769 global symbol which is defined in an object we are
1770 including in the link (i.e., DEF_REGULAR is set). At
1771 this point we have not seen all the input files, so it is
1772 possible that DEF_REGULAR is not set now but will be set
1773 later (it is never cleared). In case of a weak definition,
1774 DEF_REGULAR may be cleared later by a strong definition in
1775 a shared library. We account for that possibility below by
1776 storing information in the relocs_copied field of the hash
1777 table entry. A similar situation occurs when creating
1778 shared libraries and symbol visibility changes render the
1779 symbol local.
1780
1781 If on the other hand, we are creating an executable, we
1782 may need to keep relocations for symbols satisfied by a
1783 dynamic library if we manage to avoid copy relocs for the
1784 symbol. */
1785 if ((info->shared
1786 && (sec->flags & SEC_ALLOC) != 0
1787 && (r_type != R_386_PC32
1788 || (h != NULL
1789 && (! SYMBOLIC_BIND (info, h)
1790 || h->root.type == bfd_link_hash_defweak
1791 || !h->def_regular))))
1792 || (ELIMINATE_COPY_RELOCS
1793 && !info->shared
1794 && (sec->flags & SEC_ALLOC) != 0
1795 && h != NULL
1796 && (h->root.type == bfd_link_hash_defweak
1797 || !h->def_regular)))
1798 {
1799 struct elf_dyn_relocs *p;
1800 struct elf_dyn_relocs **head;
1801
1802 /* We must copy these reloc types into the output file.
1803 Create a reloc section in dynobj and make room for
1804 this reloc. */
1805 if (sreloc == NULL)
1806 {
1807 if (htab->elf.dynobj == NULL)
1808 htab->elf.dynobj = abfd;
1809
1810 sreloc = _bfd_elf_make_dynamic_reloc_section
1811 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1812
1813 if (sreloc == NULL)
1814 return FALSE;
1815 }
1816
1817 /* If this is a global symbol, we count the number of
1818 relocations we need for this symbol. */
1819 if (h != NULL)
1820 {
1821 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1822 }
1823 else
1824 {
1825 /* Track dynamic relocs needed for local syms too.
1826 We really need local syms available to do this
1827 easily. Oh well. */
1828 void **vpp;
1829 asection *s;
1830
1831 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1832 abfd, r_symndx);
1833 if (isym == NULL)
1834 return FALSE;
1835
1836 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1837 if (s == NULL)
1838 s = sec;
1839
1840 vpp = &elf_section_data (s)->local_dynrel;
1841 head = (struct elf_dyn_relocs **)vpp;
1842 }
1843
1844 p = *head;
1845 if (p == NULL || p->sec != sec)
1846 {
1847 bfd_size_type amt = sizeof *p;
1848 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1849 amt);
1850 if (p == NULL)
1851 return FALSE;
1852 p->next = *head;
1853 *head = p;
1854 p->sec = sec;
1855 p->count = 0;
1856 p->pc_count = 0;
1857 }
1858
1859 p->count += 1;
1860 if (r_type == R_386_PC32)
1861 p->pc_count += 1;
1862 }
1863 break;
1864
1865 /* This relocation describes the C++ object vtable hierarchy.
1866 Reconstruct it for later use during GC. */
1867 case R_386_GNU_VTINHERIT:
1868 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1869 return FALSE;
1870 break;
1871
1872 /* This relocation describes which C++ vtable entries are actually
1873 used. Record for later use during GC. */
1874 case R_386_GNU_VTENTRY:
1875 BFD_ASSERT (h != NULL);
1876 if (h != NULL
1877 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1878 return FALSE;
1879 break;
1880
1881 default:
1882 break;
1883 }
1884 }
1885
1886 return TRUE;
1887 }
1888
1889 /* Return the section that should be marked against GC for a given
1890 relocation. */
1891
1892 static asection *
1893 elf_i386_gc_mark_hook (asection *sec,
1894 struct bfd_link_info *info,
1895 Elf_Internal_Rela *rel,
1896 struct elf_link_hash_entry *h,
1897 Elf_Internal_Sym *sym)
1898 {
1899 if (h != NULL)
1900 switch (ELF32_R_TYPE (rel->r_info))
1901 {
1902 case R_386_GNU_VTINHERIT:
1903 case R_386_GNU_VTENTRY:
1904 return NULL;
1905 }
1906
1907 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1908 }
1909
1910 /* Update the got entry reference counts for the section being removed. */
1911
1912 static bfd_boolean
1913 elf_i386_gc_sweep_hook (bfd *abfd,
1914 struct bfd_link_info *info,
1915 asection *sec,
1916 const Elf_Internal_Rela *relocs)
1917 {
1918 struct elf_i386_link_hash_table *htab;
1919 Elf_Internal_Shdr *symtab_hdr;
1920 struct elf_link_hash_entry **sym_hashes;
1921 bfd_signed_vma *local_got_refcounts;
1922 const Elf_Internal_Rela *rel, *relend;
1923
1924 if (info->relocatable)
1925 return TRUE;
1926
1927 htab = elf_i386_hash_table (info);
1928 if (htab == NULL)
1929 return FALSE;
1930
1931 elf_section_data (sec)->local_dynrel = NULL;
1932
1933 symtab_hdr = &elf_symtab_hdr (abfd);
1934 sym_hashes = elf_sym_hashes (abfd);
1935 local_got_refcounts = elf_local_got_refcounts (abfd);
1936
1937 relend = relocs + sec->reloc_count;
1938 for (rel = relocs; rel < relend; rel++)
1939 {
1940 unsigned long r_symndx;
1941 unsigned int r_type;
1942 struct elf_link_hash_entry *h = NULL;
1943
1944 r_symndx = ELF32_R_SYM (rel->r_info);
1945 if (r_symndx >= symtab_hdr->sh_info)
1946 {
1947 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1948 while (h->root.type == bfd_link_hash_indirect
1949 || h->root.type == bfd_link_hash_warning)
1950 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1951 }
1952 else
1953 {
1954 /* A local symbol. */
1955 Elf_Internal_Sym *isym;
1956
1957 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1958 abfd, r_symndx);
1959
1960 /* Check relocation against local STT_GNU_IFUNC symbol. */
1961 if (isym != NULL
1962 && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1963 {
1964 h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
1965 if (h == NULL)
1966 abort ();
1967 }
1968 }
1969
1970 if (h)
1971 {
1972 struct elf_i386_link_hash_entry *eh;
1973 struct elf_dyn_relocs **pp;
1974 struct elf_dyn_relocs *p;
1975
1976 eh = (struct elf_i386_link_hash_entry *) h;
1977 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1978 if (p->sec == sec)
1979 {
1980 /* Everything must go for SEC. */
1981 *pp = p->next;
1982 break;
1983 }
1984 }
1985
1986 r_type = ELF32_R_TYPE (rel->r_info);
1987 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1988 symtab_hdr, sym_hashes,
1989 &r_type, GOT_UNKNOWN,
1990 rel, relend, h, r_symndx))
1991 return FALSE;
1992
1993 switch (r_type)
1994 {
1995 case R_386_TLS_LDM:
1996 if (htab->tls_ldm_got.refcount > 0)
1997 htab->tls_ldm_got.refcount -= 1;
1998 break;
1999
2000 case R_386_TLS_GD:
2001 case R_386_TLS_GOTDESC:
2002 case R_386_TLS_DESC_CALL:
2003 case R_386_TLS_IE_32:
2004 case R_386_TLS_IE:
2005 case R_386_TLS_GOTIE:
2006 case R_386_GOT32:
2007 if (h != NULL)
2008 {
2009 if (h->got.refcount > 0)
2010 h->got.refcount -= 1;
2011 if (h->type == STT_GNU_IFUNC)
2012 {
2013 if (h->plt.refcount > 0)
2014 h->plt.refcount -= 1;
2015 }
2016 }
2017 else if (local_got_refcounts != NULL)
2018 {
2019 if (local_got_refcounts[r_symndx] > 0)
2020 local_got_refcounts[r_symndx] -= 1;
2021 }
2022 break;
2023
2024 case R_386_32:
2025 case R_386_PC32:
2026 if (info->shared
2027 && (h == NULL || h->type != STT_GNU_IFUNC))
2028 break;
2029 /* Fall through */
2030
2031 case R_386_PLT32:
2032 if (h != NULL)
2033 {
2034 if (h->plt.refcount > 0)
2035 h->plt.refcount -= 1;
2036 }
2037 break;
2038
2039 case R_386_GOTOFF:
2040 if (h != NULL && h->type == STT_GNU_IFUNC)
2041 {
2042 if (h->got.refcount > 0)
2043 h->got.refcount -= 1;
2044 if (h->plt.refcount > 0)
2045 h->plt.refcount -= 1;
2046 }
2047 break;
2048
2049 default:
2050 break;
2051 }
2052 }
2053
2054 return TRUE;
2055 }
2056
2057 /* Adjust a symbol defined by a dynamic object and referenced by a
2058 regular object. The current definition is in some section of the
2059 dynamic object, but we're not including those sections. We have to
2060 change the definition to something the rest of the link can
2061 understand. */
2062
2063 static bfd_boolean
2064 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2065 struct elf_link_hash_entry *h)
2066 {
2067 struct elf_i386_link_hash_table *htab;
2068 asection *s;
2069 struct elf_i386_link_hash_entry *eh;
2070 struct elf_dyn_relocs *p;
2071
2072 /* STT_GNU_IFUNC symbol must go through PLT. */
2073 if (h->type == STT_GNU_IFUNC)
2074 {
2075 /* All local STT_GNU_IFUNC references must be treate as local
2076 calls via local PLT. */
2077 if (h->ref_regular
2078 && SYMBOL_CALLS_LOCAL (info, h))
2079 {
2080 bfd_size_type pc_count = 0, count = 0;
2081 struct elf_dyn_relocs **pp;
2082
2083 eh = (struct elf_i386_link_hash_entry *) h;
2084 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2085 {
2086 pc_count += p->pc_count;
2087 p->count -= p->pc_count;
2088 p->pc_count = 0;
2089 count += p->count;
2090 if (p->count == 0)
2091 *pp = p->next;
2092 else
2093 pp = &p->next;
2094 }
2095
2096 if (pc_count || count)
2097 {
2098 h->needs_plt = 1;
2099 h->plt.refcount += 1;
2100 h->non_got_ref = 1;
2101 }
2102 }
2103
2104 if (h->plt.refcount <= 0)
2105 {
2106 h->plt.offset = (bfd_vma) -1;
2107 h->needs_plt = 0;
2108 }
2109 return TRUE;
2110 }
2111
2112 /* If this is a function, put it in the procedure linkage table. We
2113 will fill in the contents of the procedure linkage table later,
2114 when we know the address of the .got section. */
2115 if (h->type == STT_FUNC
2116 || h->needs_plt)
2117 {
2118 if (h->plt.refcount <= 0
2119 || SYMBOL_CALLS_LOCAL (info, h)
2120 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2121 && h->root.type == bfd_link_hash_undefweak))
2122 {
2123 /* This case can occur if we saw a PLT32 reloc in an input
2124 file, but the symbol was never referred to by a dynamic
2125 object, or if all references were garbage collected. In
2126 such a case, we don't actually need to build a procedure
2127 linkage table, and we can just do a PC32 reloc instead. */
2128 h->plt.offset = (bfd_vma) -1;
2129 h->needs_plt = 0;
2130 }
2131
2132 return TRUE;
2133 }
2134 else
2135 /* It's possible that we incorrectly decided a .plt reloc was
2136 needed for an R_386_PC32 reloc to a non-function sym in
2137 check_relocs. We can't decide accurately between function and
2138 non-function syms in check-relocs; Objects loaded later in
2139 the link may change h->type. So fix it now. */
2140 h->plt.offset = (bfd_vma) -1;
2141
2142 /* If this is a weak symbol, and there is a real definition, the
2143 processor independent code will have arranged for us to see the
2144 real definition first, and we can just use the same value. */
2145 if (h->u.weakdef != NULL)
2146 {
2147 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2148 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2149 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2150 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2151 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2152 h->non_got_ref = h->u.weakdef->non_got_ref;
2153 return TRUE;
2154 }
2155
2156 /* This is a reference to a symbol defined by a dynamic object which
2157 is not a function. */
2158
2159 /* If we are creating a shared library, we must presume that the
2160 only references to the symbol are via the global offset table.
2161 For such cases we need not do anything here; the relocations will
2162 be handled correctly by relocate_section. */
2163 if (info->shared)
2164 return TRUE;
2165
2166 /* If there are no references to this symbol that do not use the
2167 GOT, we don't need to generate a copy reloc. */
2168 if (!h->non_got_ref)
2169 return TRUE;
2170
2171 /* If -z nocopyreloc was given, we won't generate them either. */
2172 if (info->nocopyreloc)
2173 {
2174 h->non_got_ref = 0;
2175 return TRUE;
2176 }
2177
2178 htab = elf_i386_hash_table (info);
2179 if (htab == NULL)
2180 return FALSE;
2181
2182 /* If there aren't any dynamic relocs in read-only sections, then
2183 we can keep the dynamic relocs and avoid the copy reloc. This
2184 doesn't work on VxWorks, where we can not have dynamic relocations
2185 (other than copy and jump slot relocations) in an executable. */
2186 if (ELIMINATE_COPY_RELOCS
2187 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2188 {
2189 eh = (struct elf_i386_link_hash_entry *) h;
2190 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2191 {
2192 s = p->sec->output_section;
2193 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2194 break;
2195 }
2196
2197 if (p == NULL)
2198 {
2199 h->non_got_ref = 0;
2200 return TRUE;
2201 }
2202 }
2203
2204 /* We must allocate the symbol in our .dynbss section, which will
2205 become part of the .bss section of the executable. There will be
2206 an entry for this symbol in the .dynsym section. The dynamic
2207 object will contain position independent code, so all references
2208 from the dynamic object to this symbol will go through the global
2209 offset table. The dynamic linker will use the .dynsym entry to
2210 determine the address it must put in the global offset table, so
2211 both the dynamic object and the regular object will refer to the
2212 same memory location for the variable. */
2213
2214 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2215 copy the initial value out of the dynamic object and into the
2216 runtime process image. */
2217 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2218 {
2219 htab->srelbss->size += sizeof (Elf32_External_Rel);
2220 h->needs_copy = 1;
2221 }
2222
2223 s = htab->sdynbss;
2224
2225 return _bfd_elf_adjust_dynamic_copy (h, s);
2226 }
2227
2228 /* Allocate space in .plt, .got and associated reloc sections for
2229 dynamic relocs. */
2230
2231 static bfd_boolean
2232 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2233 {
2234 struct bfd_link_info *info;
2235 struct elf_i386_link_hash_table *htab;
2236 struct elf_i386_link_hash_entry *eh;
2237 struct elf_dyn_relocs *p;
2238 unsigned plt_entry_size;
2239
2240 if (h->root.type == bfd_link_hash_indirect)
2241 return TRUE;
2242
2243 eh = (struct elf_i386_link_hash_entry *) h;
2244
2245 info = (struct bfd_link_info *) inf;
2246 htab = elf_i386_hash_table (info);
2247 if (htab == NULL)
2248 return FALSE;
2249
2250 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2251
2252 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2253 here if it is defined and referenced in a non-shared object. */
2254 if (h->type == STT_GNU_IFUNC
2255 && h->def_regular)
2256 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2257 plt_entry_size, 4);
2258 else if (htab->elf.dynamic_sections_created
2259 && h->plt.refcount > 0)
2260 {
2261 /* Make sure this symbol is output as a dynamic symbol.
2262 Undefined weak syms won't yet be marked as dynamic. */
2263 if (h->dynindx == -1
2264 && !h->forced_local)
2265 {
2266 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2267 return FALSE;
2268 }
2269
2270 if (info->shared
2271 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2272 {
2273 asection *s = htab->elf.splt;
2274
2275 /* If this is the first .plt entry, make room for the special
2276 first entry. */
2277 if (s->size == 0)
2278 s->size += plt_entry_size;
2279
2280 h->plt.offset = s->size;
2281
2282 /* If this symbol is not defined in a regular file, and we are
2283 not generating a shared library, then set the symbol to this
2284 location in the .plt. This is required to make function
2285 pointers compare as equal between the normal executable and
2286 the shared library. */
2287 if (! info->shared
2288 && !h->def_regular)
2289 {
2290 h->root.u.def.section = s;
2291 h->root.u.def.value = h->plt.offset;
2292 }
2293
2294 /* Make room for this entry. */
2295 s->size += plt_entry_size;
2296
2297 /* We also need to make an entry in the .got.plt section, which
2298 will be placed in the .got section by the linker script. */
2299 htab->elf.sgotplt->size += 4;
2300
2301 /* We also need to make an entry in the .rel.plt section. */
2302 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2303 htab->elf.srelplt->reloc_count++;
2304
2305 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2306 && !info->shared)
2307 {
2308 /* VxWorks has a second set of relocations for each PLT entry
2309 in executables. They go in a separate relocation section,
2310 which is processed by the kernel loader. */
2311
2312 /* There are two relocations for the initial PLT entry: an
2313 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2314 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2315
2316 if (h->plt.offset == plt_entry_size)
2317 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2318
2319 /* There are two extra relocations for each subsequent PLT entry:
2320 an R_386_32 relocation for the GOT entry, and an R_386_32
2321 relocation for the PLT entry. */
2322
2323 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2324 }
2325 }
2326 else
2327 {
2328 h->plt.offset = (bfd_vma) -1;
2329 h->needs_plt = 0;
2330 }
2331 }
2332 else
2333 {
2334 h->plt.offset = (bfd_vma) -1;
2335 h->needs_plt = 0;
2336 }
2337
2338 eh->tlsdesc_got = (bfd_vma) -1;
2339
2340 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2341 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2342 if (h->got.refcount > 0
2343 && info->executable
2344 && h->dynindx == -1
2345 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2346 h->got.offset = (bfd_vma) -1;
2347 else if (h->got.refcount > 0)
2348 {
2349 asection *s;
2350 bfd_boolean dyn;
2351 int tls_type = elf_i386_hash_entry(h)->tls_type;
2352
2353 /* Make sure this symbol is output as a dynamic symbol.
2354 Undefined weak syms won't yet be marked as dynamic. */
2355 if (h->dynindx == -1
2356 && !h->forced_local)
2357 {
2358 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2359 return FALSE;
2360 }
2361
2362 s = htab->elf.sgot;
2363 if (GOT_TLS_GDESC_P (tls_type))
2364 {
2365 eh->tlsdesc_got = htab->elf.sgotplt->size
2366 - elf_i386_compute_jump_table_size (htab);
2367 htab->elf.sgotplt->size += 8;
2368 h->got.offset = (bfd_vma) -2;
2369 }
2370 if (! GOT_TLS_GDESC_P (tls_type)
2371 || GOT_TLS_GD_P (tls_type))
2372 {
2373 h->got.offset = s->size;
2374 s->size += 4;
2375 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2376 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2377 s->size += 4;
2378 }
2379 dyn = htab->elf.dynamic_sections_created;
2380 /* R_386_TLS_IE_32 needs one dynamic relocation,
2381 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2382 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2383 need two), R_386_TLS_GD needs one if local symbol and two if
2384 global. */
2385 if (tls_type == GOT_TLS_IE_BOTH)
2386 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2387 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2388 || (tls_type & GOT_TLS_IE))
2389 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2390 else if (GOT_TLS_GD_P (tls_type))
2391 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2392 else if (! GOT_TLS_GDESC_P (tls_type)
2393 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2394 || h->root.type != bfd_link_hash_undefweak)
2395 && (info->shared
2396 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2397 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2398 if (GOT_TLS_GDESC_P (tls_type))
2399 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2400 }
2401 else
2402 h->got.offset = (bfd_vma) -1;
2403
2404 if (eh->dyn_relocs == NULL)
2405 return TRUE;
2406
2407 /* In the shared -Bsymbolic case, discard space allocated for
2408 dynamic pc-relative relocs against symbols which turn out to be
2409 defined in regular objects. For the normal shared case, discard
2410 space for pc-relative relocs that have become local due to symbol
2411 visibility changes. */
2412
2413 if (info->shared)
2414 {
2415 /* The only reloc that uses pc_count is R_386_PC32, which will
2416 appear on a call or on something like ".long foo - .". We
2417 want calls to protected symbols to resolve directly to the
2418 function rather than going via the plt. If people want
2419 function pointer comparisons to work as expected then they
2420 should avoid writing assembly like ".long foo - .". */
2421 if (SYMBOL_CALLS_LOCAL (info, h))
2422 {
2423 struct elf_dyn_relocs **pp;
2424
2425 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2426 {
2427 p->count -= p->pc_count;
2428 p->pc_count = 0;
2429 if (p->count == 0)
2430 *pp = p->next;
2431 else
2432 pp = &p->next;
2433 }
2434 }
2435
2436 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2437 {
2438 struct elf_dyn_relocs **pp;
2439 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2440 {
2441 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2442 *pp = p->next;
2443 else
2444 pp = &p->next;
2445 }
2446 }
2447
2448 /* Also discard relocs on undefined weak syms with non-default
2449 visibility. */
2450 if (eh->dyn_relocs != NULL
2451 && h->root.type == bfd_link_hash_undefweak)
2452 {
2453 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2454 eh->dyn_relocs = NULL;
2455
2456 /* Make sure undefined weak symbols are output as a dynamic
2457 symbol in PIEs. */
2458 else if (h->dynindx == -1
2459 && !h->forced_local)
2460 {
2461 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2462 return FALSE;
2463 }
2464 }
2465 }
2466 else if (ELIMINATE_COPY_RELOCS)
2467 {
2468 /* For the non-shared case, discard space for relocs against
2469 symbols which turn out to need copy relocs or are not
2470 dynamic. */
2471
2472 if (!h->non_got_ref
2473 && ((h->def_dynamic
2474 && !h->def_regular)
2475 || (htab->elf.dynamic_sections_created
2476 && (h->root.type == bfd_link_hash_undefweak
2477 || h->root.type == bfd_link_hash_undefined))))
2478 {
2479 /* Make sure this symbol is output as a dynamic symbol.
2480 Undefined weak syms won't yet be marked as dynamic. */
2481 if (h->dynindx == -1
2482 && !h->forced_local)
2483 {
2484 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2485 return FALSE;
2486 }
2487
2488 /* If that succeeded, we know we'll be keeping all the
2489 relocs. */
2490 if (h->dynindx != -1)
2491 goto keep;
2492 }
2493
2494 eh->dyn_relocs = NULL;
2495
2496 keep: ;
2497 }
2498
2499 /* Finally, allocate space. */
2500 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2501 {
2502 asection *sreloc;
2503
2504 sreloc = elf_section_data (p->sec)->sreloc;
2505
2506 BFD_ASSERT (sreloc != NULL);
2507 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2508 }
2509
2510 return TRUE;
2511 }
2512
2513 /* Allocate space in .plt, .got and associated reloc sections for
2514 local dynamic relocs. */
2515
2516 static bfd_boolean
2517 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2518 {
2519 struct elf_link_hash_entry *h
2520 = (struct elf_link_hash_entry *) *slot;
2521
2522 if (h->type != STT_GNU_IFUNC
2523 || !h->def_regular
2524 || !h->ref_regular
2525 || !h->forced_local
2526 || h->root.type != bfd_link_hash_defined)
2527 abort ();
2528
2529 return elf_i386_allocate_dynrelocs (h, inf);
2530 }
2531
2532 /* Find any dynamic relocs that apply to read-only sections. */
2533
2534 static bfd_boolean
2535 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2536 {
2537 struct elf_i386_link_hash_entry *eh;
2538 struct elf_dyn_relocs *p;
2539
2540 /* Skip local IFUNC symbols. */
2541 if (h->forced_local && h->type == STT_GNU_IFUNC)
2542 return TRUE;
2543
2544 eh = (struct elf_i386_link_hash_entry *) h;
2545 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2546 {
2547 asection *s = p->sec->output_section;
2548
2549 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2550 {
2551 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2552
2553 info->flags |= DF_TEXTREL;
2554
2555 if (info->warn_shared_textrel && info->shared)
2556 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2557 p->sec->owner, h->root.root.string,
2558 p->sec);
2559
2560 /* Not an error, just cut short the traversal. */
2561 return FALSE;
2562 }
2563 }
2564 return TRUE;
2565 }
2566
2567 /* Convert
2568 mov foo@GOT(%reg), %reg
2569 to
2570 lea foo@GOTOFF(%reg), %reg
2571 with the local symbol, foo. */
2572
2573 static bfd_boolean
2574 elf_i386_convert_mov_to_lea (bfd *abfd, asection *sec,
2575 struct bfd_link_info *link_info)
2576 {
2577 Elf_Internal_Shdr *symtab_hdr;
2578 Elf_Internal_Rela *internal_relocs;
2579 Elf_Internal_Rela *irel, *irelend;
2580 bfd_byte *contents;
2581 struct elf_i386_link_hash_table *htab;
2582 bfd_boolean changed_contents;
2583 bfd_boolean changed_relocs;
2584 bfd_signed_vma *local_got_refcounts;
2585
2586 /* Don't even try to convert non-ELF outputs. */
2587 if (!is_elf_hash_table (link_info->hash))
2588 return FALSE;
2589
2590 /* Nothing to do if there are no codes, no relocations or no output. */
2591 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2592 || sec->reloc_count == 0
2593 || discarded_section (sec))
2594 return TRUE;
2595
2596 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2597
2598 /* Load the relocations for this section. */
2599 internal_relocs = (_bfd_elf_link_read_relocs
2600 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2601 link_info->keep_memory));
2602 if (internal_relocs == NULL)
2603 return FALSE;
2604
2605 htab = elf_i386_hash_table (link_info);
2606 changed_contents = FALSE;
2607 changed_relocs = FALSE;
2608 local_got_refcounts = elf_local_got_refcounts (abfd);
2609
2610 /* Get the section contents. */
2611 if (elf_section_data (sec)->this_hdr.contents != NULL)
2612 contents = elf_section_data (sec)->this_hdr.contents;
2613 else
2614 {
2615 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2616 goto error_return;
2617 }
2618
2619 irelend = internal_relocs + sec->reloc_count;
2620 for (irel = internal_relocs; irel < irelend; irel++)
2621 {
2622 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2623 unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2624 unsigned int indx;
2625 struct elf_link_hash_entry *h;
2626
2627 if (r_type != R_386_GOT32)
2628 continue;
2629
2630 /* Get the symbol referred to by the reloc. */
2631 if (r_symndx < symtab_hdr->sh_info)
2632 {
2633 Elf_Internal_Sym *isym;
2634
2635 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2636 abfd, r_symndx);
2637
2638 /* STT_GNU_IFUNC must keep R_386_GOT32 relocation. */
2639 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2640 && bfd_get_8 (input_bfd,
2641 contents + irel->r_offset - 2) == 0x8b)
2642 {
2643 bfd_put_8 (output_bfd, 0x8d,
2644 contents + irel->r_offset - 2);
2645 irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2646 if (local_got_refcounts != NULL
2647 && local_got_refcounts[r_symndx] > 0)
2648 local_got_refcounts[r_symndx] -= 1;
2649 changed_contents = TRUE;
2650 changed_relocs = TRUE;
2651 }
2652 continue;
2653 }
2654
2655 indx = r_symndx - symtab_hdr->sh_info;
2656 h = elf_sym_hashes (abfd)[indx];
2657 BFD_ASSERT (h != NULL);
2658
2659 while (h->root.type == bfd_link_hash_indirect
2660 || h->root.type == bfd_link_hash_warning)
2661 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2662
2663 /* STT_GNU_IFUNC must keep R_386_GOT32 relocation. We also avoid
2664 optimizing _DYNAMIC since ld.so may use its link-time address. */
2665 if (h->def_regular
2666 && h->type != STT_GNU_IFUNC
2667 && h != htab->elf.hdynamic
2668 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2669 && bfd_get_8 (input_bfd,
2670 contents + irel->r_offset - 2) == 0x8b)
2671 {
2672 bfd_put_8 (output_bfd, 0x8d,
2673 contents + irel->r_offset - 2);
2674 irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2675 if (h->got.refcount > 0)
2676 h->got.refcount -= 1;
2677 changed_contents = TRUE;
2678 changed_relocs = TRUE;
2679 }
2680 }
2681
2682 if (contents != NULL
2683 && elf_section_data (sec)->this_hdr.contents != contents)
2684 {
2685 if (!changed_contents && !link_info->keep_memory)
2686 free (contents);
2687 else
2688 {
2689 /* Cache the section contents for elf_link_input_bfd. */
2690 elf_section_data (sec)->this_hdr.contents = contents;
2691 }
2692 }
2693
2694 if (elf_section_data (sec)->relocs != internal_relocs)
2695 {
2696 if (!changed_relocs)
2697 free (internal_relocs);
2698 else
2699 elf_section_data (sec)->relocs = internal_relocs;
2700 }
2701
2702 return TRUE;
2703
2704 error_return:
2705 if (contents != NULL
2706 && elf_section_data (sec)->this_hdr.contents != contents)
2707 free (contents);
2708 if (internal_relocs != NULL
2709 && elf_section_data (sec)->relocs != internal_relocs)
2710 free (internal_relocs);
2711 return FALSE;
2712 }
2713
2714 /* Set the sizes of the dynamic sections. */
2715
2716 static bfd_boolean
2717 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2718 {
2719 struct elf_i386_link_hash_table *htab;
2720 bfd *dynobj;
2721 asection *s;
2722 bfd_boolean relocs;
2723 bfd *ibfd;
2724
2725 htab = elf_i386_hash_table (info);
2726 if (htab == NULL)
2727 return FALSE;
2728 dynobj = htab->elf.dynobj;
2729 if (dynobj == NULL)
2730 abort ();
2731
2732 if (htab->elf.dynamic_sections_created)
2733 {
2734 /* Set the contents of the .interp section to the interpreter. */
2735 if (info->executable)
2736 {
2737 s = bfd_get_linker_section (dynobj, ".interp");
2738 if (s == NULL)
2739 abort ();
2740 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2741 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2742 }
2743 }
2744
2745 /* Set up .got offsets for local syms, and space for local dynamic
2746 relocs. */
2747 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2748 {
2749 bfd_signed_vma *local_got;
2750 bfd_signed_vma *end_local_got;
2751 char *local_tls_type;
2752 bfd_vma *local_tlsdesc_gotent;
2753 bfd_size_type locsymcount;
2754 Elf_Internal_Shdr *symtab_hdr;
2755 asection *srel;
2756
2757 if (! is_i386_elf (ibfd))
2758 continue;
2759
2760 for (s = ibfd->sections; s != NULL; s = s->next)
2761 {
2762 struct elf_dyn_relocs *p;
2763
2764 if (!elf_i386_convert_mov_to_lea (ibfd, s, info))
2765 return FALSE;
2766
2767 for (p = ((struct elf_dyn_relocs *)
2768 elf_section_data (s)->local_dynrel);
2769 p != NULL;
2770 p = p->next)
2771 {
2772 if (!bfd_is_abs_section (p->sec)
2773 && bfd_is_abs_section (p->sec->output_section))
2774 {
2775 /* Input section has been discarded, either because
2776 it is a copy of a linkonce section or due to
2777 linker script /DISCARD/, so we'll be discarding
2778 the relocs too. */
2779 }
2780 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2781 && strcmp (p->sec->output_section->name,
2782 ".tls_vars") == 0)
2783 {
2784 /* Relocations in vxworks .tls_vars sections are
2785 handled specially by the loader. */
2786 }
2787 else if (p->count != 0)
2788 {
2789 srel = elf_section_data (p->sec)->sreloc;
2790 srel->size += p->count * sizeof (Elf32_External_Rel);
2791 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2792 && (info->flags & DF_TEXTREL) == 0)
2793 {
2794 info->flags |= DF_TEXTREL;
2795 if (info->warn_shared_textrel && info->shared)
2796 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2797 p->sec->owner, p->sec);
2798 }
2799 }
2800 }
2801 }
2802
2803 local_got = elf_local_got_refcounts (ibfd);
2804 if (!local_got)
2805 continue;
2806
2807 symtab_hdr = &elf_symtab_hdr (ibfd);
2808 locsymcount = symtab_hdr->sh_info;
2809 end_local_got = local_got + locsymcount;
2810 local_tls_type = elf_i386_local_got_tls_type (ibfd);
2811 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2812 s = htab->elf.sgot;
2813 srel = htab->elf.srelgot;
2814 for (; local_got < end_local_got;
2815 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2816 {
2817 *local_tlsdesc_gotent = (bfd_vma) -1;
2818 if (*local_got > 0)
2819 {
2820 if (GOT_TLS_GDESC_P (*local_tls_type))
2821 {
2822 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2823 - elf_i386_compute_jump_table_size (htab);
2824 htab->elf.sgotplt->size += 8;
2825 *local_got = (bfd_vma) -2;
2826 }
2827 if (! GOT_TLS_GDESC_P (*local_tls_type)
2828 || GOT_TLS_GD_P (*local_tls_type))
2829 {
2830 *local_got = s->size;
2831 s->size += 4;
2832 if (GOT_TLS_GD_P (*local_tls_type)
2833 || *local_tls_type == GOT_TLS_IE_BOTH)
2834 s->size += 4;
2835 }
2836 if (info->shared
2837 || GOT_TLS_GD_ANY_P (*local_tls_type)
2838 || (*local_tls_type & GOT_TLS_IE))
2839 {
2840 if (*local_tls_type == GOT_TLS_IE_BOTH)
2841 srel->size += 2 * sizeof (Elf32_External_Rel);
2842 else if (GOT_TLS_GD_P (*local_tls_type)
2843 || ! GOT_TLS_GDESC_P (*local_tls_type))
2844 srel->size += sizeof (Elf32_External_Rel);
2845 if (GOT_TLS_GDESC_P (*local_tls_type))
2846 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2847 }
2848 }
2849 else
2850 *local_got = (bfd_vma) -1;
2851 }
2852 }
2853
2854 if (htab->tls_ldm_got.refcount > 0)
2855 {
2856 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2857 relocs. */
2858 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2859 htab->elf.sgot->size += 8;
2860 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2861 }
2862 else
2863 htab->tls_ldm_got.offset = -1;
2864
2865 /* Allocate global sym .plt and .got entries, and space for global
2866 sym dynamic relocs. */
2867 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2868
2869 /* Allocate .plt and .got entries, and space for local symbols. */
2870 htab_traverse (htab->loc_hash_table,
2871 elf_i386_allocate_local_dynrelocs,
2872 info);
2873
2874 /* For every jump slot reserved in the sgotplt, reloc_count is
2875 incremented. However, when we reserve space for TLS descriptors,
2876 it's not incremented, so in order to compute the space reserved
2877 for them, it suffices to multiply the reloc count by the jump
2878 slot size.
2879
2880 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2881 so that R_386_IRELATIVE entries come last. */
2882 if (htab->elf.srelplt)
2883 {
2884 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2885 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2886 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2887 }
2888 else if (htab->elf.irelplt)
2889 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2890
2891
2892 if (htab->elf.sgotplt)
2893 {
2894 /* Don't allocate .got.plt section if there are no GOT nor PLT
2895 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
2896 if ((htab->elf.hgot == NULL
2897 || !htab->elf.hgot->ref_regular_nonweak)
2898 && (htab->elf.sgotplt->size
2899 == get_elf_backend_data (output_bfd)->got_header_size)
2900 && (htab->elf.splt == NULL
2901 || htab->elf.splt->size == 0)
2902 && (htab->elf.sgot == NULL
2903 || htab->elf.sgot->size == 0)
2904 && (htab->elf.iplt == NULL
2905 || htab->elf.iplt->size == 0)
2906 && (htab->elf.igotplt == NULL
2907 || htab->elf.igotplt->size == 0))
2908 htab->elf.sgotplt->size = 0;
2909 }
2910
2911
2912 if (htab->plt_eh_frame != NULL
2913 && htab->elf.splt != NULL
2914 && htab->elf.splt->size != 0
2915 && !bfd_is_abs_section (htab->elf.splt->output_section)
2916 && _bfd_elf_eh_frame_present (info))
2917 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2918
2919 /* We now have determined the sizes of the various dynamic sections.
2920 Allocate memory for them. */
2921 relocs = FALSE;
2922 for (s = dynobj->sections; s != NULL; s = s->next)
2923 {
2924 bfd_boolean strip_section = TRUE;
2925
2926 if ((s->flags & SEC_LINKER_CREATED) == 0)
2927 continue;
2928
2929 if (s == htab->elf.splt
2930 || s == htab->elf.sgot)
2931 {
2932 /* Strip this section if we don't need it; see the
2933 comment below. */
2934 /* We'd like to strip these sections if they aren't needed, but if
2935 we've exported dynamic symbols from them we must leave them.
2936 It's too late to tell BFD to get rid of the symbols. */
2937
2938 if (htab->elf.hplt != NULL)
2939 strip_section = FALSE;
2940 }
2941 else if (s == htab->elf.sgotplt
2942 || s == htab->elf.iplt
2943 || s == htab->elf.igotplt
2944 || s == htab->plt_eh_frame
2945 || s == htab->sdynbss)
2946 {
2947 /* Strip these too. */
2948 }
2949 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2950 {
2951 if (s->size != 0
2952 && s != htab->elf.srelplt
2953 && s != htab->srelplt2)
2954 relocs = TRUE;
2955
2956 /* We use the reloc_count field as a counter if we need
2957 to copy relocs into the output file. */
2958 s->reloc_count = 0;
2959 }
2960 else
2961 {
2962 /* It's not one of our sections, so don't allocate space. */
2963 continue;
2964 }
2965
2966 if (s->size == 0)
2967 {
2968 /* If we don't need this section, strip it from the
2969 output file. This is mostly to handle .rel.bss and
2970 .rel.plt. We must create both sections in
2971 create_dynamic_sections, because they must be created
2972 before the linker maps input sections to output
2973 sections. The linker does that before
2974 adjust_dynamic_symbol is called, and it is that
2975 function which decides whether anything needs to go
2976 into these sections. */
2977 if (strip_section)
2978 s->flags |= SEC_EXCLUDE;
2979 continue;
2980 }
2981
2982 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2983 continue;
2984
2985 /* Allocate memory for the section contents. We use bfd_zalloc
2986 here in case unused entries are not reclaimed before the
2987 section's contents are written out. This should not happen,
2988 but this way if it does, we get a R_386_NONE reloc instead
2989 of garbage. */
2990 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2991 if (s->contents == NULL)
2992 return FALSE;
2993 }
2994
2995 if (htab->plt_eh_frame != NULL
2996 && htab->plt_eh_frame->contents != NULL)
2997 {
2998 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2999 sizeof (elf_i386_eh_frame_plt));
3000 bfd_put_32 (dynobj, htab->elf.splt->size,
3001 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3002 }
3003
3004 if (htab->elf.dynamic_sections_created)
3005 {
3006 /* Add some entries to the .dynamic section. We fill in the
3007 values later, in elf_i386_finish_dynamic_sections, but we
3008 must add the entries now so that we get the correct size for
3009 the .dynamic section. The DT_DEBUG entry is filled in by the
3010 dynamic linker and used by the debugger. */
3011 #define add_dynamic_entry(TAG, VAL) \
3012 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3013
3014 if (info->executable)
3015 {
3016 if (!add_dynamic_entry (DT_DEBUG, 0))
3017 return FALSE;
3018 }
3019
3020 if (htab->elf.splt->size != 0)
3021 {
3022 if (!add_dynamic_entry (DT_PLTGOT, 0)
3023 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3024 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3025 || !add_dynamic_entry (DT_JMPREL, 0))
3026 return FALSE;
3027 }
3028
3029 if (relocs)
3030 {
3031 if (!add_dynamic_entry (DT_REL, 0)
3032 || !add_dynamic_entry (DT_RELSZ, 0)
3033 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3034 return FALSE;
3035
3036 /* If any dynamic relocs apply to a read-only section,
3037 then we need a DT_TEXTREL entry. */
3038 if ((info->flags & DF_TEXTREL) == 0)
3039 elf_link_hash_traverse (&htab->elf,
3040 elf_i386_readonly_dynrelocs, info);
3041
3042 if ((info->flags & DF_TEXTREL) != 0)
3043 {
3044 if (!add_dynamic_entry (DT_TEXTREL, 0))
3045 return FALSE;
3046 }
3047 }
3048 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3049 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3050 return FALSE;
3051 }
3052 #undef add_dynamic_entry
3053
3054 return TRUE;
3055 }
3056
3057 static bfd_boolean
3058 elf_i386_always_size_sections (bfd *output_bfd,
3059 struct bfd_link_info *info)
3060 {
3061 asection *tls_sec = elf_hash_table (info)->tls_sec;
3062
3063 if (tls_sec)
3064 {
3065 struct elf_link_hash_entry *tlsbase;
3066
3067 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3068 "_TLS_MODULE_BASE_",
3069 FALSE, FALSE, FALSE);
3070
3071 if (tlsbase && tlsbase->type == STT_TLS)
3072 {
3073 struct elf_i386_link_hash_table *htab;
3074 struct bfd_link_hash_entry *bh = NULL;
3075 const struct elf_backend_data *bed
3076 = get_elf_backend_data (output_bfd);
3077
3078 htab = elf_i386_hash_table (info);
3079 if (htab == NULL)
3080 return FALSE;
3081
3082 if (!(_bfd_generic_link_add_one_symbol
3083 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3084 tls_sec, 0, NULL, FALSE,
3085 bed->collect, &bh)))
3086 return FALSE;
3087
3088 htab->tls_module_base = bh;
3089
3090 tlsbase = (struct elf_link_hash_entry *)bh;
3091 tlsbase->def_regular = 1;
3092 tlsbase->other = STV_HIDDEN;
3093 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3094 }
3095 }
3096
3097 return TRUE;
3098 }
3099
3100 /* Set the correct type for an x86 ELF section. We do this by the
3101 section name, which is a hack, but ought to work. */
3102
3103 static bfd_boolean
3104 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3105 Elf_Internal_Shdr *hdr,
3106 asection *sec)
3107 {
3108 const char *name;
3109
3110 name = bfd_get_section_name (abfd, sec);
3111
3112 /* This is an ugly, but unfortunately necessary hack that is
3113 needed when producing EFI binaries on x86. It tells
3114 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3115 containing ELF relocation info. We need this hack in order to
3116 be able to generate ELF binaries that can be translated into
3117 EFI applications (which are essentially COFF objects). Those
3118 files contain a COFF ".reloc" section inside an ELFNN object,
3119 which would normally cause BFD to segfault because it would
3120 attempt to interpret this section as containing relocation
3121 entries for section "oc". With this hack enabled, ".reloc"
3122 will be treated as a normal data section, which will avoid the
3123 segfault. However, you won't be able to create an ELFNN binary
3124 with a section named "oc" that needs relocations, but that's
3125 the kind of ugly side-effects you get when detecting section
3126 types based on their names... In practice, this limitation is
3127 unlikely to bite. */
3128 if (strcmp (name, ".reloc") == 0)
3129 hdr->sh_type = SHT_PROGBITS;
3130
3131 return TRUE;
3132 }
3133
3134 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3135 executables. Rather than setting it to the beginning of the TLS
3136 section, we have to set it to the end. This function may be called
3137 multiple times, it is idempotent. */
3138
3139 static void
3140 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3141 {
3142 struct elf_i386_link_hash_table *htab;
3143 struct bfd_link_hash_entry *base;
3144
3145 if (!info->executable)
3146 return;
3147
3148 htab = elf_i386_hash_table (info);
3149 if (htab == NULL)
3150 return;
3151
3152 base = htab->tls_module_base;
3153 if (base == NULL)
3154 return;
3155
3156 base->u.def.value = htab->elf.tls_size;
3157 }
3158
3159 /* Return the base VMA address which should be subtracted from real addresses
3160 when resolving @dtpoff relocation.
3161 This is PT_TLS segment p_vaddr. */
3162
3163 static bfd_vma
3164 elf_i386_dtpoff_base (struct bfd_link_info *info)
3165 {
3166 /* If tls_sec is NULL, we should have signalled an error already. */
3167 if (elf_hash_table (info)->tls_sec == NULL)
3168 return 0;
3169 return elf_hash_table (info)->tls_sec->vma;
3170 }
3171
3172 /* Return the relocation value for @tpoff relocation
3173 if STT_TLS virtual address is ADDRESS. */
3174
3175 static bfd_vma
3176 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3177 {
3178 struct elf_link_hash_table *htab = elf_hash_table (info);
3179 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3180 bfd_vma static_tls_size;
3181
3182 /* If tls_sec is NULL, we should have signalled an error already. */
3183 if (htab->tls_sec == NULL)
3184 return 0;
3185
3186 /* Consider special static TLS alignment requirements. */
3187 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3188 return static_tls_size + htab->tls_sec->vma - address;
3189 }
3190
3191 /* Relocate an i386 ELF section. */
3192
3193 static bfd_boolean
3194 elf_i386_relocate_section (bfd *output_bfd,
3195 struct bfd_link_info *info,
3196 bfd *input_bfd,
3197 asection *input_section,
3198 bfd_byte *contents,
3199 Elf_Internal_Rela *relocs,
3200 Elf_Internal_Sym *local_syms,
3201 asection **local_sections)
3202 {
3203 struct elf_i386_link_hash_table *htab;
3204 Elf_Internal_Shdr *symtab_hdr;
3205 struct elf_link_hash_entry **sym_hashes;
3206 bfd_vma *local_got_offsets;
3207 bfd_vma *local_tlsdesc_gotents;
3208 Elf_Internal_Rela *rel;
3209 Elf_Internal_Rela *relend;
3210 bfd_boolean is_vxworks_tls;
3211 unsigned plt_entry_size;
3212
3213 BFD_ASSERT (is_i386_elf (input_bfd));
3214
3215 htab = elf_i386_hash_table (info);
3216 if (htab == NULL)
3217 return FALSE;
3218 symtab_hdr = &elf_symtab_hdr (input_bfd);
3219 sym_hashes = elf_sym_hashes (input_bfd);
3220 local_got_offsets = elf_local_got_offsets (input_bfd);
3221 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3222 /* We have to handle relocations in vxworks .tls_vars sections
3223 specially, because the dynamic loader is 'weird'. */
3224 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3225 && info->shared
3226 && !strcmp (input_section->output_section->name,
3227 ".tls_vars"));
3228
3229 elf_i386_set_tls_module_base (info);
3230
3231 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3232
3233 rel = relocs;
3234 relend = relocs + input_section->reloc_count;
3235 for (; rel < relend; rel++)
3236 {
3237 unsigned int r_type;
3238 reloc_howto_type *howto;
3239 unsigned long r_symndx;
3240 struct elf_link_hash_entry *h;
3241 Elf_Internal_Sym *sym;
3242 asection *sec;
3243 bfd_vma off, offplt;
3244 bfd_vma relocation;
3245 bfd_boolean unresolved_reloc;
3246 bfd_reloc_status_type r;
3247 unsigned int indx;
3248 int tls_type;
3249
3250 r_type = ELF32_R_TYPE (rel->r_info);
3251 if (r_type == R_386_GNU_VTINHERIT
3252 || r_type == R_386_GNU_VTENTRY)
3253 continue;
3254
3255 if ((indx = r_type) >= R_386_standard
3256 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3257 >= R_386_ext - R_386_standard)
3258 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3259 >= R_386_irelative - R_386_ext))
3260 {
3261 (*_bfd_error_handler)
3262 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3263 input_bfd, input_section, r_type);
3264 bfd_set_error (bfd_error_bad_value);
3265 return FALSE;
3266 }
3267 howto = elf_howto_table + indx;
3268
3269 r_symndx = ELF32_R_SYM (rel->r_info);
3270 h = NULL;
3271 sym = NULL;
3272 sec = NULL;
3273 unresolved_reloc = FALSE;
3274 if (r_symndx < symtab_hdr->sh_info)
3275 {
3276 sym = local_syms + r_symndx;
3277 sec = local_sections[r_symndx];
3278 relocation = (sec->output_section->vma
3279 + sec->output_offset
3280 + sym->st_value);
3281
3282 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3283 && ((sec->flags & SEC_MERGE) != 0
3284 || (info->relocatable
3285 && sec->output_offset != 0)))
3286 {
3287 bfd_vma addend;
3288 bfd_byte *where = contents + rel->r_offset;
3289
3290 switch (howto->size)
3291 {
3292 case 0:
3293 addend = bfd_get_8 (input_bfd, where);
3294 if (howto->pc_relative)
3295 {
3296 addend = (addend ^ 0x80) - 0x80;
3297 addend += 1;
3298 }
3299 break;
3300 case 1:
3301 addend = bfd_get_16 (input_bfd, where);
3302 if (howto->pc_relative)
3303 {
3304 addend = (addend ^ 0x8000) - 0x8000;
3305 addend += 2;
3306 }
3307 break;
3308 case 2:
3309 addend = bfd_get_32 (input_bfd, where);
3310 if (howto->pc_relative)
3311 {
3312 addend = (addend ^ 0x80000000) - 0x80000000;
3313 addend += 4;
3314 }
3315 break;
3316 default:
3317 abort ();
3318 }
3319
3320 if (info->relocatable)
3321 addend += sec->output_offset;
3322 else
3323 {
3324 asection *msec = sec;
3325 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3326 addend);
3327 addend -= relocation;
3328 addend += msec->output_section->vma + msec->output_offset;
3329 }
3330
3331 switch (howto->size)
3332 {
3333 case 0:
3334 /* FIXME: overflow checks. */
3335 if (howto->pc_relative)
3336 addend -= 1;
3337 bfd_put_8 (input_bfd, addend, where);
3338 break;
3339 case 1:
3340 if (howto->pc_relative)
3341 addend -= 2;
3342 bfd_put_16 (input_bfd, addend, where);
3343 break;
3344 case 2:
3345 if (howto->pc_relative)
3346 addend -= 4;
3347 bfd_put_32 (input_bfd, addend, where);
3348 break;
3349 }
3350 }
3351 else if (!info->relocatable
3352 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3353 {
3354 /* Relocate against local STT_GNU_IFUNC symbol. */
3355 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3356 FALSE);
3357 if (h == NULL)
3358 abort ();
3359
3360 /* Set STT_GNU_IFUNC symbol value. */
3361 h->root.u.def.value = sym->st_value;
3362 h->root.u.def.section = sec;
3363 }
3364 }
3365 else
3366 {
3367 bfd_boolean warned ATTRIBUTE_UNUSED;
3368
3369 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3370 r_symndx, symtab_hdr, sym_hashes,
3371 h, sec, relocation,
3372 unresolved_reloc, warned);
3373 }
3374
3375 if (sec != NULL && discarded_section (sec))
3376 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3377 rel, 1, relend, howto, 0, contents);
3378
3379 if (info->relocatable)
3380 continue;
3381
3382 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3383 it here if it is defined in a non-shared object. */
3384 if (h != NULL
3385 && h->type == STT_GNU_IFUNC
3386 && h->def_regular)
3387 {
3388 asection *plt, *gotplt, *base_got;
3389 bfd_vma plt_index;
3390 const char *name;
3391
3392 if ((input_section->flags & SEC_ALLOC) == 0
3393 || h->plt.offset == (bfd_vma) -1)
3394 abort ();
3395
3396 /* STT_GNU_IFUNC symbol must go through PLT. */
3397 if (htab->elf.splt != NULL)
3398 {
3399 plt = htab->elf.splt;
3400 gotplt = htab->elf.sgotplt;
3401 }
3402 else
3403 {
3404 plt = htab->elf.iplt;
3405 gotplt = htab->elf.igotplt;
3406 }
3407
3408 relocation = (plt->output_section->vma
3409 + plt->output_offset + h->plt.offset);
3410
3411 switch (r_type)
3412 {
3413 default:
3414 if (h->root.root.string)
3415 name = h->root.root.string;
3416 else
3417 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3418 NULL);
3419 (*_bfd_error_handler)
3420 (_("%B: relocation %s against STT_GNU_IFUNC "
3421 "symbol `%s' isn't handled by %s"), input_bfd,
3422 elf_howto_table[r_type].name,
3423 name, __FUNCTION__);
3424 bfd_set_error (bfd_error_bad_value);
3425 return FALSE;
3426
3427 case R_386_32:
3428 /* Generate dynamic relcoation only when there is a
3429 non-GOT reference in a shared object. */
3430 if (info->shared && h->non_got_ref)
3431 {
3432 Elf_Internal_Rela outrel;
3433 bfd_byte *loc;
3434 asection *sreloc;
3435 bfd_vma offset;
3436
3437 /* Need a dynamic relocation to get the real function
3438 adddress. */
3439 offset = _bfd_elf_section_offset (output_bfd,
3440 info,
3441 input_section,
3442 rel->r_offset);
3443 if (offset == (bfd_vma) -1
3444 || offset == (bfd_vma) -2)
3445 abort ();
3446
3447 outrel.r_offset = (input_section->output_section->vma
3448 + input_section->output_offset
3449 + offset);
3450
3451 if (h->dynindx == -1
3452 || h->forced_local
3453 || info->executable)
3454 {
3455 /* This symbol is resolved locally. */
3456 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3457 bfd_put_32 (output_bfd,
3458 (h->root.u.def.value
3459 + h->root.u.def.section->output_section->vma
3460 + h->root.u.def.section->output_offset),
3461 contents + offset);
3462 }
3463 else
3464 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3465
3466 sreloc = htab->elf.irelifunc;
3467 loc = sreloc->contents;
3468 loc += (sreloc->reloc_count++
3469 * sizeof (Elf32_External_Rel));
3470 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3471
3472 /* If this reloc is against an external symbol, we
3473 do not want to fiddle with the addend. Otherwise,
3474 we need to include the symbol value so that it
3475 becomes an addend for the dynamic reloc. For an
3476 internal symbol, we have updated addend. */
3477 continue;
3478 }
3479 /* FALLTHROUGH */
3480 case R_386_PC32:
3481 case R_386_PLT32:
3482 goto do_relocation;
3483
3484 case R_386_GOT32:
3485 base_got = htab->elf.sgot;
3486 off = h->got.offset;
3487
3488 if (base_got == NULL)
3489 abort ();
3490
3491 if (off == (bfd_vma) -1)
3492 {
3493 /* We can't use h->got.offset here to save state, or
3494 even just remember the offset, as finish_dynamic_symbol
3495 would use that as offset into .got. */
3496
3497 if (htab->elf.splt != NULL)
3498 {
3499 plt_index = h->plt.offset / plt_entry_size - 1;
3500 off = (plt_index + 3) * 4;
3501 base_got = htab->elf.sgotplt;
3502 }
3503 else
3504 {
3505 plt_index = h->plt.offset / plt_entry_size;
3506 off = plt_index * 4;
3507 base_got = htab->elf.igotplt;
3508 }
3509
3510 if (h->dynindx == -1
3511 || h->forced_local
3512 || info->symbolic)
3513 {
3514 /* This references the local defitionion. We must
3515 initialize this entry in the global offset table.
3516 Since the offset must always be a multiple of 8,
3517 we use the least significant bit to record
3518 whether we have initialized it already.
3519
3520 When doing a dynamic link, we create a .rela.got
3521 relocation entry to initialize the value. This
3522 is done in the finish_dynamic_symbol routine. */
3523 if ((off & 1) != 0)
3524 off &= ~1;
3525 else
3526 {
3527 bfd_put_32 (output_bfd, relocation,
3528 base_got->contents + off);
3529 h->got.offset |= 1;
3530 }
3531 }
3532
3533 relocation = off;
3534
3535 /* Adjust for static executables. */
3536 if (htab->elf.splt == NULL)
3537 relocation += gotplt->output_offset;
3538 }
3539 else
3540 {
3541 relocation = (base_got->output_section->vma
3542 + base_got->output_offset + off
3543 - gotplt->output_section->vma
3544 - gotplt->output_offset);
3545 /* Adjust for static executables. */
3546 if (htab->elf.splt == NULL)
3547 relocation += gotplt->output_offset;
3548 }
3549
3550 goto do_relocation;
3551
3552 case R_386_GOTOFF:
3553 relocation -= (gotplt->output_section->vma
3554 + gotplt->output_offset);
3555 goto do_relocation;
3556 }
3557 }
3558
3559 switch (r_type)
3560 {
3561 case R_386_GOT32:
3562 /* Relocation is to the entry for this symbol in the global
3563 offset table. */
3564 if (htab->elf.sgot == NULL)
3565 abort ();
3566
3567 if (h != NULL)
3568 {
3569 bfd_boolean dyn;
3570
3571 off = h->got.offset;
3572 dyn = htab->elf.dynamic_sections_created;
3573 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3574 || (info->shared
3575 && SYMBOL_REFERENCES_LOCAL (info, h))
3576 || (ELF_ST_VISIBILITY (h->other)
3577 && h->root.type == bfd_link_hash_undefweak))
3578 {
3579 /* This is actually a static link, or it is a
3580 -Bsymbolic link and the symbol is defined
3581 locally, or the symbol was forced to be local
3582 because of a version file. We must initialize
3583 this entry in the global offset table. Since the
3584 offset must always be a multiple of 4, we use the
3585 least significant bit to record whether we have
3586 initialized it already.
3587
3588 When doing a dynamic link, we create a .rel.got
3589 relocation entry to initialize the value. This
3590 is done in the finish_dynamic_symbol routine. */
3591 if ((off & 1) != 0)
3592 off &= ~1;
3593 else
3594 {
3595 bfd_put_32 (output_bfd, relocation,
3596 htab->elf.sgot->contents + off);
3597 h->got.offset |= 1;
3598 }
3599 }
3600 else
3601 unresolved_reloc = FALSE;
3602 }
3603 else
3604 {
3605 if (local_got_offsets == NULL)
3606 abort ();
3607
3608 off = local_got_offsets[r_symndx];
3609
3610 /* The offset must always be a multiple of 4. We use
3611 the least significant bit to record whether we have
3612 already generated the necessary reloc. */
3613 if ((off & 1) != 0)
3614 off &= ~1;
3615 else
3616 {
3617 bfd_put_32 (output_bfd, relocation,
3618 htab->elf.sgot->contents + off);
3619
3620 if (info->shared)
3621 {
3622 asection *s;
3623 Elf_Internal_Rela outrel;
3624 bfd_byte *loc;
3625
3626 s = htab->elf.srelgot;
3627 if (s == NULL)
3628 abort ();
3629
3630 outrel.r_offset = (htab->elf.sgot->output_section->vma
3631 + htab->elf.sgot->output_offset
3632 + off);
3633 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3634 loc = s->contents;
3635 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
3636 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3637 }
3638
3639 local_got_offsets[r_symndx] |= 1;
3640 }
3641 }
3642
3643 if (off >= (bfd_vma) -2)
3644 abort ();
3645
3646 relocation = htab->elf.sgot->output_section->vma
3647 + htab->elf.sgot->output_offset + off
3648 - htab->elf.sgotplt->output_section->vma
3649 - htab->elf.sgotplt->output_offset;
3650 break;
3651
3652 case R_386_GOTOFF:
3653 /* Relocation is relative to the start of the global offset
3654 table. */
3655
3656 /* Check to make sure it isn't a protected function symbol
3657 for shared library since it may not be local when used
3658 as function address. We also need to make sure that a
3659 symbol is defined locally. */
3660 if (info->shared && h)
3661 {
3662 if (!h->def_regular)
3663 {
3664 const char *v;
3665
3666 switch (ELF_ST_VISIBILITY (h->other))
3667 {
3668 case STV_HIDDEN:
3669 v = _("hidden symbol");
3670 break;
3671 case STV_INTERNAL:
3672 v = _("internal symbol");
3673 break;
3674 case STV_PROTECTED:
3675 v = _("protected symbol");
3676 break;
3677 default:
3678 v = _("symbol");
3679 break;
3680 }
3681
3682 (*_bfd_error_handler)
3683 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3684 input_bfd, v, h->root.root.string);
3685 bfd_set_error (bfd_error_bad_value);
3686 return FALSE;
3687 }
3688 else if (!info->executable
3689 && !SYMBOLIC_BIND (info, h)
3690 && h->type == STT_FUNC
3691 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3692 {
3693 (*_bfd_error_handler)
3694 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3695 input_bfd, h->root.root.string);
3696 bfd_set_error (bfd_error_bad_value);
3697 return FALSE;
3698 }
3699 }
3700
3701 /* Note that sgot is not involved in this
3702 calculation. We always want the start of .got.plt. If we
3703 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3704 permitted by the ABI, we might have to change this
3705 calculation. */
3706 relocation -= htab->elf.sgotplt->output_section->vma
3707 + htab->elf.sgotplt->output_offset;
3708 break;
3709
3710 case R_386_GOTPC:
3711 /* Use global offset table as symbol value. */
3712 relocation = htab->elf.sgotplt->output_section->vma
3713 + htab->elf.sgotplt->output_offset;
3714 unresolved_reloc = FALSE;
3715 break;
3716
3717 case R_386_PLT32:
3718 /* Relocation is to the entry for this symbol in the
3719 procedure linkage table. */
3720
3721 /* Resolve a PLT32 reloc against a local symbol directly,
3722 without using the procedure linkage table. */
3723 if (h == NULL)
3724 break;
3725
3726 if (h->plt.offset == (bfd_vma) -1
3727 || htab->elf.splt == NULL)
3728 {
3729 /* We didn't make a PLT entry for this symbol. This
3730 happens when statically linking PIC code, or when
3731 using -Bsymbolic. */
3732 break;
3733 }
3734
3735 relocation = (htab->elf.splt->output_section->vma
3736 + htab->elf.splt->output_offset
3737 + h->plt.offset);
3738 unresolved_reloc = FALSE;
3739 break;
3740
3741 case R_386_32:
3742 case R_386_PC32:
3743 if ((input_section->flags & SEC_ALLOC) == 0
3744 || is_vxworks_tls)
3745 break;
3746
3747 if ((info->shared
3748 && (h == NULL
3749 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3750 || h->root.type != bfd_link_hash_undefweak)
3751 && (r_type != R_386_PC32
3752 || !SYMBOL_CALLS_LOCAL (info, h)))
3753 || (ELIMINATE_COPY_RELOCS
3754 && !info->shared
3755 && h != NULL
3756 && h->dynindx != -1
3757 && !h->non_got_ref
3758 && ((h->def_dynamic
3759 && !h->def_regular)
3760 || h->root.type == bfd_link_hash_undefweak
3761 || h->root.type == bfd_link_hash_undefined)))
3762 {
3763 Elf_Internal_Rela outrel;
3764 bfd_byte *loc;
3765 bfd_boolean skip, relocate;
3766 asection *sreloc;
3767
3768 /* When generating a shared object, these relocations
3769 are copied into the output file to be resolved at run
3770 time. */
3771
3772 skip = FALSE;
3773 relocate = FALSE;
3774
3775 outrel.r_offset =
3776 _bfd_elf_section_offset (output_bfd, info, input_section,
3777 rel->r_offset);
3778 if (outrel.r_offset == (bfd_vma) -1)
3779 skip = TRUE;
3780 else if (outrel.r_offset == (bfd_vma) -2)
3781 skip = TRUE, relocate = TRUE;
3782 outrel.r_offset += (input_section->output_section->vma
3783 + input_section->output_offset);
3784
3785 if (skip)
3786 memset (&outrel, 0, sizeof outrel);
3787 else if (h != NULL
3788 && h->dynindx != -1
3789 && (r_type == R_386_PC32
3790 || !info->shared
3791 || !SYMBOLIC_BIND (info, h)
3792 || !h->def_regular))
3793 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3794 else
3795 {
3796 /* This symbol is local, or marked to become local. */
3797 relocate = TRUE;
3798 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3799 }
3800
3801 sreloc = elf_section_data (input_section)->sreloc;
3802
3803 if (sreloc == NULL || sreloc->contents == NULL)
3804 {
3805 r = bfd_reloc_notsupported;
3806 goto check_relocation_error;
3807 }
3808
3809 loc = sreloc->contents;
3810 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3811
3812 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3813
3814 /* If this reloc is against an external symbol, we do
3815 not want to fiddle with the addend. Otherwise, we
3816 need to include the symbol value so that it becomes
3817 an addend for the dynamic reloc. */
3818 if (! relocate)
3819 continue;
3820 }
3821 break;
3822
3823 case R_386_TLS_IE:
3824 if (!info->executable)
3825 {
3826 Elf_Internal_Rela outrel;
3827 bfd_byte *loc;
3828 asection *sreloc;
3829
3830 outrel.r_offset = rel->r_offset
3831 + input_section->output_section->vma
3832 + input_section->output_offset;
3833 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3834 sreloc = elf_section_data (input_section)->sreloc;
3835 if (sreloc == NULL)
3836 abort ();
3837 loc = sreloc->contents;
3838 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3839 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3840 }
3841 /* Fall through */
3842
3843 case R_386_TLS_GD:
3844 case R_386_TLS_GOTDESC:
3845 case R_386_TLS_DESC_CALL:
3846 case R_386_TLS_IE_32:
3847 case R_386_TLS_GOTIE:
3848 tls_type = GOT_UNKNOWN;
3849 if (h == NULL && local_got_offsets)
3850 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3851 else if (h != NULL)
3852 tls_type = elf_i386_hash_entry(h)->tls_type;
3853 if (tls_type == GOT_TLS_IE)
3854 tls_type = GOT_TLS_IE_NEG;
3855
3856 if (! elf_i386_tls_transition (info, input_bfd,
3857 input_section, contents,
3858 symtab_hdr, sym_hashes,
3859 &r_type, tls_type, rel,
3860 relend, h, r_symndx))
3861 return FALSE;
3862
3863 if (r_type == R_386_TLS_LE_32)
3864 {
3865 BFD_ASSERT (! unresolved_reloc);
3866 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3867 {
3868 unsigned int type;
3869 bfd_vma roff;
3870
3871 /* GD->LE transition. */
3872 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3873 if (type == 0x04)
3874 {
3875 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3876 Change it into:
3877 movl %gs:0, %eax; subl $foo@tpoff, %eax
3878 (6 byte form of subl). */
3879 memcpy (contents + rel->r_offset - 3,
3880 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3881 roff = rel->r_offset + 5;
3882 }
3883 else
3884 {
3885 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3886 Change it into:
3887 movl %gs:0, %eax; subl $foo@tpoff, %eax
3888 (6 byte form of subl). */
3889 memcpy (contents + rel->r_offset - 2,
3890 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3891 roff = rel->r_offset + 6;
3892 }
3893 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3894 contents + roff);
3895 /* Skip R_386_PC32/R_386_PLT32. */
3896 rel++;
3897 continue;
3898 }
3899 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3900 {
3901 /* GDesc -> LE transition.
3902 It's originally something like:
3903 leal x@tlsdesc(%ebx), %eax
3904
3905 leal x@ntpoff, %eax
3906
3907 Registers other than %eax may be set up here. */
3908
3909 unsigned int val;
3910 bfd_vma roff;
3911
3912 roff = rel->r_offset;
3913 val = bfd_get_8 (input_bfd, contents + roff - 1);
3914
3915 /* Now modify the instruction as appropriate. */
3916 /* aoliva FIXME: remove the above and xor the byte
3917 below with 0x86. */
3918 bfd_put_8 (output_bfd, val ^ 0x86,
3919 contents + roff - 1);
3920 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3921 contents + roff);
3922 continue;
3923 }
3924 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3925 {
3926 /* GDesc -> LE transition.
3927 It's originally:
3928 call *(%eax)
3929 Turn it into:
3930 xchg %ax,%ax */
3931
3932 bfd_vma roff;
3933
3934 roff = rel->r_offset;
3935 bfd_put_8 (output_bfd, 0x66, contents + roff);
3936 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3937 continue;
3938 }
3939 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3940 {
3941 unsigned int val;
3942
3943 /* IE->LE transition:
3944 Originally it can be one of:
3945 movl foo, %eax
3946 movl foo, %reg
3947 addl foo, %reg
3948 We change it into:
3949 movl $foo, %eax
3950 movl $foo, %reg
3951 addl $foo, %reg. */
3952 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3953 if (val == 0xa1)
3954 {
3955 /* movl foo, %eax. */
3956 bfd_put_8 (output_bfd, 0xb8,
3957 contents + rel->r_offset - 1);
3958 }
3959 else
3960 {
3961 unsigned int type;
3962
3963 type = bfd_get_8 (input_bfd,
3964 contents + rel->r_offset - 2);
3965 switch (type)
3966 {
3967 case 0x8b:
3968 /* movl */
3969 bfd_put_8 (output_bfd, 0xc7,
3970 contents + rel->r_offset - 2);
3971 bfd_put_8 (output_bfd,
3972 0xc0 | ((val >> 3) & 7),
3973 contents + rel->r_offset - 1);
3974 break;
3975 case 0x03:
3976 /* addl */
3977 bfd_put_8 (output_bfd, 0x81,
3978 contents + rel->r_offset - 2);
3979 bfd_put_8 (output_bfd,
3980 0xc0 | ((val >> 3) & 7),
3981 contents + rel->r_offset - 1);
3982 break;
3983 default:
3984 BFD_FAIL ();
3985 break;
3986 }
3987 }
3988 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3989 contents + rel->r_offset);
3990 continue;
3991 }
3992 else
3993 {
3994 unsigned int val, type;
3995
3996 /* {IE_32,GOTIE}->LE transition:
3997 Originally it can be one of:
3998 subl foo(%reg1), %reg2
3999 movl foo(%reg1), %reg2
4000 addl foo(%reg1), %reg2
4001 We change it into:
4002 subl $foo, %reg2
4003 movl $foo, %reg2 (6 byte form)
4004 addl $foo, %reg2. */
4005 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4006 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4007 if (type == 0x8b)
4008 {
4009 /* movl */
4010 bfd_put_8 (output_bfd, 0xc7,
4011 contents + rel->r_offset - 2);
4012 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4013 contents + rel->r_offset - 1);
4014 }
4015 else if (type == 0x2b)
4016 {
4017 /* subl */
4018 bfd_put_8 (output_bfd, 0x81,
4019 contents + rel->r_offset - 2);
4020 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4021 contents + rel->r_offset - 1);
4022 }
4023 else if (type == 0x03)
4024 {
4025 /* addl */
4026 bfd_put_8 (output_bfd, 0x81,
4027 contents + rel->r_offset - 2);
4028 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4029 contents + rel->r_offset - 1);
4030 }
4031 else
4032 BFD_FAIL ();
4033 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4034 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4035 contents + rel->r_offset);
4036 else
4037 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4038 contents + rel->r_offset);
4039 continue;
4040 }
4041 }
4042
4043 if (htab->elf.sgot == NULL)
4044 abort ();
4045
4046 if (h != NULL)
4047 {
4048 off = h->got.offset;
4049 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4050 }
4051 else
4052 {
4053 if (local_got_offsets == NULL)
4054 abort ();
4055
4056 off = local_got_offsets[r_symndx];
4057 offplt = local_tlsdesc_gotents[r_symndx];
4058 }
4059
4060 if ((off & 1) != 0)
4061 off &= ~1;
4062 else
4063 {
4064 Elf_Internal_Rela outrel;
4065 bfd_byte *loc;
4066 int dr_type;
4067 asection *sreloc;
4068
4069 if (htab->elf.srelgot == NULL)
4070 abort ();
4071
4072 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4073
4074 if (GOT_TLS_GDESC_P (tls_type))
4075 {
4076 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4077 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4078 <= htab->elf.sgotplt->size);
4079 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4080 + htab->elf.sgotplt->output_offset
4081 + offplt
4082 + htab->sgotplt_jump_table_size);
4083 sreloc = htab->elf.srelplt;
4084 loc = sreloc->contents;
4085 loc += (htab->next_tls_desc_index++
4086 * sizeof (Elf32_External_Rel));
4087 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4088 <= sreloc->contents + sreloc->size);
4089 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4090 if (indx == 0)
4091 {
4092 BFD_ASSERT (! unresolved_reloc);
4093 bfd_put_32 (output_bfd,
4094 relocation - elf_i386_dtpoff_base (info),
4095 htab->elf.sgotplt->contents + offplt
4096 + htab->sgotplt_jump_table_size + 4);
4097 }
4098 else
4099 {
4100 bfd_put_32 (output_bfd, 0,
4101 htab->elf.sgotplt->contents + offplt
4102 + htab->sgotplt_jump_table_size + 4);
4103 }
4104 }
4105
4106 sreloc = htab->elf.srelgot;
4107
4108 outrel.r_offset = (htab->elf.sgot->output_section->vma
4109 + htab->elf.sgot->output_offset + off);
4110
4111 if (GOT_TLS_GD_P (tls_type))
4112 dr_type = R_386_TLS_DTPMOD32;
4113 else if (GOT_TLS_GDESC_P (tls_type))
4114 goto dr_done;
4115 else if (tls_type == GOT_TLS_IE_POS)
4116 dr_type = R_386_TLS_TPOFF;
4117 else
4118 dr_type = R_386_TLS_TPOFF32;
4119
4120 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4121 bfd_put_32 (output_bfd,
4122 relocation - elf_i386_dtpoff_base (info),
4123 htab->elf.sgot->contents + off);
4124 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4125 bfd_put_32 (output_bfd,
4126 elf_i386_dtpoff_base (info) - relocation,
4127 htab->elf.sgot->contents + off);
4128 else if (dr_type != R_386_TLS_DESC)
4129 bfd_put_32 (output_bfd, 0,
4130 htab->elf.sgot->contents + off);
4131 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4132
4133 loc = sreloc->contents;
4134 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
4135 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4136 <= sreloc->contents + sreloc->size);
4137 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4138
4139 if (GOT_TLS_GD_P (tls_type))
4140 {
4141 if (indx == 0)
4142 {
4143 BFD_ASSERT (! unresolved_reloc);
4144 bfd_put_32 (output_bfd,
4145 relocation - elf_i386_dtpoff_base (info),
4146 htab->elf.sgot->contents + off + 4);
4147 }
4148 else
4149 {
4150 bfd_put_32 (output_bfd, 0,
4151 htab->elf.sgot->contents + off + 4);
4152 outrel.r_info = ELF32_R_INFO (indx,
4153 R_386_TLS_DTPOFF32);
4154 outrel.r_offset += 4;
4155 sreloc->reloc_count++;
4156 loc += sizeof (Elf32_External_Rel);
4157 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4158 <= sreloc->contents + sreloc->size);
4159 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4160 }
4161 }
4162 else if (tls_type == GOT_TLS_IE_BOTH)
4163 {
4164 bfd_put_32 (output_bfd,
4165 (indx == 0
4166 ? relocation - elf_i386_dtpoff_base (info)
4167 : 0),
4168 htab->elf.sgot->contents + off + 4);
4169 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4170 outrel.r_offset += 4;
4171 sreloc->reloc_count++;
4172 loc += sizeof (Elf32_External_Rel);
4173 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4174 }
4175
4176 dr_done:
4177 if (h != NULL)
4178 h->got.offset |= 1;
4179 else
4180 local_got_offsets[r_symndx] |= 1;
4181 }
4182
4183 if (off >= (bfd_vma) -2
4184 && ! GOT_TLS_GDESC_P (tls_type))
4185 abort ();
4186 if (r_type == R_386_TLS_GOTDESC
4187 || r_type == R_386_TLS_DESC_CALL)
4188 {
4189 relocation = htab->sgotplt_jump_table_size + offplt;
4190 unresolved_reloc = FALSE;
4191 }
4192 else if (r_type == ELF32_R_TYPE (rel->r_info))
4193 {
4194 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4195 + htab->elf.sgotplt->output_offset;
4196 relocation = htab->elf.sgot->output_section->vma
4197 + htab->elf.sgot->output_offset + off - g_o_t;
4198 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4199 && tls_type == GOT_TLS_IE_BOTH)
4200 relocation += 4;
4201 if (r_type == R_386_TLS_IE)
4202 relocation += g_o_t;
4203 unresolved_reloc = FALSE;
4204 }
4205 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4206 {
4207 unsigned int val, type;
4208 bfd_vma roff;
4209
4210 /* GD->IE transition. */
4211 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4212 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4213 if (type == 0x04)
4214 {
4215 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4216 Change it into:
4217 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4218 val >>= 3;
4219 roff = rel->r_offset - 3;
4220 }
4221 else
4222 {
4223 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4224 Change it into:
4225 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4226 roff = rel->r_offset - 2;
4227 }
4228 memcpy (contents + roff,
4229 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4230 contents[roff + 7] = 0x80 | (val & 7);
4231 /* If foo is used only with foo@gotntpoff(%reg) and
4232 foo@indntpoff, but not with foo@gottpoff(%reg), change
4233 subl $foo@gottpoff(%reg), %eax
4234 into:
4235 addl $foo@gotntpoff(%reg), %eax. */
4236 if (tls_type == GOT_TLS_IE_POS)
4237 contents[roff + 6] = 0x03;
4238 bfd_put_32 (output_bfd,
4239 htab->elf.sgot->output_section->vma
4240 + htab->elf.sgot->output_offset + off
4241 - htab->elf.sgotplt->output_section->vma
4242 - htab->elf.sgotplt->output_offset,
4243 contents + roff + 8);
4244 /* Skip R_386_PLT32. */
4245 rel++;
4246 continue;
4247 }
4248 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4249 {
4250 /* GDesc -> IE transition.
4251 It's originally something like:
4252 leal x@tlsdesc(%ebx), %eax
4253
4254 Change it to:
4255 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4256 or:
4257 movl x@gottpoff(%ebx), %eax # before negl %eax
4258
4259 Registers other than %eax may be set up here. */
4260
4261 bfd_vma roff;
4262
4263 /* First, make sure it's a leal adding ebx to a 32-bit
4264 offset into any register, although it's probably
4265 almost always going to be eax. */
4266 roff = rel->r_offset;
4267
4268 /* Now modify the instruction as appropriate. */
4269 /* To turn a leal into a movl in the form we use it, it
4270 suffices to change the first byte from 0x8d to 0x8b.
4271 aoliva FIXME: should we decide to keep the leal, all
4272 we have to do is remove the statement below, and
4273 adjust the relaxation of R_386_TLS_DESC_CALL. */
4274 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4275
4276 if (tls_type == GOT_TLS_IE_BOTH)
4277 off += 4;
4278
4279 bfd_put_32 (output_bfd,
4280 htab->elf.sgot->output_section->vma
4281 + htab->elf.sgot->output_offset + off
4282 - htab->elf.sgotplt->output_section->vma
4283 - htab->elf.sgotplt->output_offset,
4284 contents + roff);
4285 continue;
4286 }
4287 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4288 {
4289 /* GDesc -> IE transition.
4290 It's originally:
4291 call *(%eax)
4292
4293 Change it to:
4294 xchg %ax,%ax
4295 or
4296 negl %eax
4297 depending on how we transformed the TLS_GOTDESC above.
4298 */
4299
4300 bfd_vma roff;
4301
4302 roff = rel->r_offset;
4303
4304 /* Now modify the instruction as appropriate. */
4305 if (tls_type != GOT_TLS_IE_NEG)
4306 {
4307 /* xchg %ax,%ax */
4308 bfd_put_8 (output_bfd, 0x66, contents + roff);
4309 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4310 }
4311 else
4312 {
4313 /* negl %eax */
4314 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4315 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4316 }
4317
4318 continue;
4319 }
4320 else
4321 BFD_ASSERT (FALSE);
4322 break;
4323
4324 case R_386_TLS_LDM:
4325 if (! elf_i386_tls_transition (info, input_bfd,
4326 input_section, contents,
4327 symtab_hdr, sym_hashes,
4328 &r_type, GOT_UNKNOWN, rel,
4329 relend, h, r_symndx))
4330 return FALSE;
4331
4332 if (r_type != R_386_TLS_LDM)
4333 {
4334 /* LD->LE transition:
4335 leal foo(%reg), %eax; call ___tls_get_addr.
4336 We change it into:
4337 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4338 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4339 memcpy (contents + rel->r_offset - 2,
4340 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4341 /* Skip R_386_PC32/R_386_PLT32. */
4342 rel++;
4343 continue;
4344 }
4345
4346 if (htab->elf.sgot == NULL)
4347 abort ();
4348
4349 off = htab->tls_ldm_got.offset;
4350 if (off & 1)
4351 off &= ~1;
4352 else
4353 {
4354 Elf_Internal_Rela outrel;
4355 bfd_byte *loc;
4356
4357 if (htab->elf.srelgot == NULL)
4358 abort ();
4359
4360 outrel.r_offset = (htab->elf.sgot->output_section->vma
4361 + htab->elf.sgot->output_offset + off);
4362
4363 bfd_put_32 (output_bfd, 0,
4364 htab->elf.sgot->contents + off);
4365 bfd_put_32 (output_bfd, 0,
4366 htab->elf.sgot->contents + off + 4);
4367 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4368 loc = htab->elf.srelgot->contents;
4369 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4370 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4371 htab->tls_ldm_got.offset |= 1;
4372 }
4373 relocation = htab->elf.sgot->output_section->vma
4374 + htab->elf.sgot->output_offset + off
4375 - htab->elf.sgotplt->output_section->vma
4376 - htab->elf.sgotplt->output_offset;
4377 unresolved_reloc = FALSE;
4378 break;
4379
4380 case R_386_TLS_LDO_32:
4381 if (!info->executable || (input_section->flags & SEC_CODE) == 0)
4382 relocation -= elf_i386_dtpoff_base (info);
4383 else
4384 /* When converting LDO to LE, we must negate. */
4385 relocation = -elf_i386_tpoff (info, relocation);
4386 break;
4387
4388 case R_386_TLS_LE_32:
4389 case R_386_TLS_LE:
4390 if (!info->executable)
4391 {
4392 Elf_Internal_Rela outrel;
4393 asection *sreloc;
4394 bfd_byte *loc;
4395
4396 outrel.r_offset = rel->r_offset
4397 + input_section->output_section->vma
4398 + input_section->output_offset;
4399 if (h != NULL && h->dynindx != -1)
4400 indx = h->dynindx;
4401 else
4402 indx = 0;
4403 if (r_type == R_386_TLS_LE_32)
4404 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4405 else
4406 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4407 sreloc = elf_section_data (input_section)->sreloc;
4408 if (sreloc == NULL)
4409 abort ();
4410 loc = sreloc->contents;
4411 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
4412 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4413 if (indx)
4414 continue;
4415 else if (r_type == R_386_TLS_LE_32)
4416 relocation = elf_i386_dtpoff_base (info) - relocation;
4417 else
4418 relocation -= elf_i386_dtpoff_base (info);
4419 }
4420 else if (r_type == R_386_TLS_LE_32)
4421 relocation = elf_i386_tpoff (info, relocation);
4422 else
4423 relocation = -elf_i386_tpoff (info, relocation);
4424 break;
4425
4426 default:
4427 break;
4428 }
4429
4430 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4431 because such sections are not SEC_ALLOC and thus ld.so will
4432 not process them. */
4433 if (unresolved_reloc
4434 && !((input_section->flags & SEC_DEBUGGING) != 0
4435 && h->def_dynamic)
4436 && _bfd_elf_section_offset (output_bfd, info, input_section,
4437 rel->r_offset) != (bfd_vma) -1)
4438 {
4439 (*_bfd_error_handler)
4440 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4441 input_bfd,
4442 input_section,
4443 (long) rel->r_offset,
4444 howto->name,
4445 h->root.root.string);
4446 return FALSE;
4447 }
4448
4449 do_relocation:
4450 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4451 contents, rel->r_offset,
4452 relocation, 0);
4453
4454 check_relocation_error:
4455 if (r != bfd_reloc_ok)
4456 {
4457 const char *name;
4458
4459 if (h != NULL)
4460 name = h->root.root.string;
4461 else
4462 {
4463 name = bfd_elf_string_from_elf_section (input_bfd,
4464 symtab_hdr->sh_link,
4465 sym->st_name);
4466 if (name == NULL)
4467 return FALSE;
4468 if (*name == '\0')
4469 name = bfd_section_name (input_bfd, sec);
4470 }
4471
4472 if (r == bfd_reloc_overflow)
4473 {
4474 if (! ((*info->callbacks->reloc_overflow)
4475 (info, (h ? &h->root : NULL), name, howto->name,
4476 (bfd_vma) 0, input_bfd, input_section,
4477 rel->r_offset)))
4478 return FALSE;
4479 }
4480 else
4481 {
4482 (*_bfd_error_handler)
4483 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4484 input_bfd, input_section,
4485 (long) rel->r_offset, name, (int) r);
4486 return FALSE;
4487 }
4488 }
4489 }
4490
4491 return TRUE;
4492 }
4493
4494 /* Finish up dynamic symbol handling. We set the contents of various
4495 dynamic sections here. */
4496
4497 static bfd_boolean
4498 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4499 struct bfd_link_info *info,
4500 struct elf_link_hash_entry *h,
4501 Elf_Internal_Sym *sym)
4502 {
4503 struct elf_i386_link_hash_table *htab;
4504 unsigned plt_entry_size;
4505 const struct elf_i386_backend_data *abed;
4506
4507 htab = elf_i386_hash_table (info);
4508 if (htab == NULL)
4509 return FALSE;
4510
4511 abed = get_elf_i386_backend_data (output_bfd);
4512 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4513
4514 if (h->plt.offset != (bfd_vma) -1)
4515 {
4516 bfd_vma plt_index;
4517 bfd_vma got_offset;
4518 Elf_Internal_Rela rel;
4519 bfd_byte *loc;
4520 asection *plt, *gotplt, *relplt;
4521
4522 /* When building a static executable, use .iplt, .igot.plt and
4523 .rel.iplt sections for STT_GNU_IFUNC symbols. */
4524 if (htab->elf.splt != NULL)
4525 {
4526 plt = htab->elf.splt;
4527 gotplt = htab->elf.sgotplt;
4528 relplt = htab->elf.srelplt;
4529 }
4530 else
4531 {
4532 plt = htab->elf.iplt;
4533 gotplt = htab->elf.igotplt;
4534 relplt = htab->elf.irelplt;
4535 }
4536
4537 /* This symbol has an entry in the procedure linkage table. Set
4538 it up. */
4539
4540 if ((h->dynindx == -1
4541 && !((h->forced_local || info->executable)
4542 && h->def_regular
4543 && h->type == STT_GNU_IFUNC))
4544 || plt == NULL
4545 || gotplt == NULL
4546 || relplt == NULL)
4547 abort ();
4548
4549 /* Get the index in the procedure linkage table which
4550 corresponds to this symbol. This is the index of this symbol
4551 in all the symbols for which we are making plt entries. The
4552 first entry in the procedure linkage table is reserved.
4553
4554 Get the offset into the .got table of the entry that
4555 corresponds to this function. Each .got entry is 4 bytes.
4556 The first three are reserved.
4557
4558 For static executables, we don't reserve anything. */
4559
4560 if (plt == htab->elf.splt)
4561 {
4562 got_offset = h->plt.offset / plt_entry_size - 1;
4563 got_offset = (got_offset + 3) * 4;
4564 }
4565 else
4566 {
4567 got_offset = h->plt.offset / plt_entry_size;
4568 got_offset = got_offset * 4;
4569 }
4570
4571 /* Fill in the entry in the procedure linkage table. */
4572 if (! info->shared)
4573 {
4574 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4575 abed->plt->plt_entry_size);
4576 bfd_put_32 (output_bfd,
4577 (gotplt->output_section->vma
4578 + gotplt->output_offset
4579 + got_offset),
4580 plt->contents + h->plt.offset
4581 + abed->plt->plt_got_offset);
4582
4583 if (abed->is_vxworks)
4584 {
4585 int s, k, reloc_index;
4586
4587 /* Create the R_386_32 relocation referencing the GOT
4588 for this PLT entry. */
4589
4590 /* S: Current slot number (zero-based). */
4591 s = ((h->plt.offset - abed->plt->plt_entry_size)
4592 / abed->plt->plt_entry_size);
4593 /* K: Number of relocations for PLTResolve. */
4594 if (info->shared)
4595 k = PLTRESOLVE_RELOCS_SHLIB;
4596 else
4597 k = PLTRESOLVE_RELOCS;
4598 /* Skip the PLTresolve relocations, and the relocations for
4599 the other PLT slots. */
4600 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4601 loc = (htab->srelplt2->contents + reloc_index
4602 * sizeof (Elf32_External_Rel));
4603
4604 rel.r_offset = (htab->elf.splt->output_section->vma
4605 + htab->elf.splt->output_offset
4606 + h->plt.offset + 2),
4607 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4608 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4609
4610 /* Create the R_386_32 relocation referencing the beginning of
4611 the PLT for this GOT entry. */
4612 rel.r_offset = (htab->elf.sgotplt->output_section->vma
4613 + htab->elf.sgotplt->output_offset
4614 + got_offset);
4615 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4616 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4617 loc + sizeof (Elf32_External_Rel));
4618 }
4619 }
4620 else
4621 {
4622 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4623 abed->plt->plt_entry_size);
4624 bfd_put_32 (output_bfd, got_offset,
4625 plt->contents + h->plt.offset
4626 + abed->plt->plt_got_offset);
4627 }
4628
4629 /* Fill in the entry in the global offset table. */
4630 bfd_put_32 (output_bfd,
4631 (plt->output_section->vma
4632 + plt->output_offset
4633 + h->plt.offset
4634 + abed->plt->plt_lazy_offset),
4635 gotplt->contents + got_offset);
4636
4637 /* Fill in the entry in the .rel.plt section. */
4638 rel.r_offset = (gotplt->output_section->vma
4639 + gotplt->output_offset
4640 + got_offset);
4641 if (h->dynindx == -1
4642 || ((info->executable
4643 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4644 && h->def_regular
4645 && h->type == STT_GNU_IFUNC))
4646 {
4647 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4648 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4649 in the .got.plt section. */
4650 bfd_put_32 (output_bfd,
4651 (h->root.u.def.value
4652 + h->root.u.def.section->output_section->vma
4653 + h->root.u.def.section->output_offset),
4654 gotplt->contents + got_offset);
4655 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4656 /* R_386_IRELATIVE comes last. */
4657 plt_index = htab->next_irelative_index--;
4658 }
4659 else
4660 {
4661 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4662 plt_index = htab->next_jump_slot_index++;
4663 }
4664 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
4665 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4666
4667 /* Don't fill PLT entry for static executables. */
4668 if (plt == htab->elf.splt)
4669 {
4670 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4671 plt->contents + h->plt.offset
4672 + abed->plt->plt_reloc_offset);
4673 bfd_put_32 (output_bfd, - (h->plt.offset
4674 + abed->plt->plt_plt_offset + 4),
4675 plt->contents + h->plt.offset
4676 + abed->plt->plt_plt_offset);
4677 }
4678
4679 if (!h->def_regular)
4680 {
4681 /* Mark the symbol as undefined, rather than as defined in
4682 the .plt section. Leave the value if there were any
4683 relocations where pointer equality matters (this is a clue
4684 for the dynamic linker, to make function pointer
4685 comparisons work between an application and shared
4686 library), otherwise set it to zero. If a function is only
4687 called from a binary, there is no need to slow down
4688 shared libraries because of that. */
4689 sym->st_shndx = SHN_UNDEF;
4690 if (!h->pointer_equality_needed)
4691 sym->st_value = 0;
4692 }
4693 }
4694
4695 if (h->got.offset != (bfd_vma) -1
4696 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
4697 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
4698 {
4699 Elf_Internal_Rela rel;
4700 bfd_byte *loc;
4701
4702 /* This symbol has an entry in the global offset table. Set it
4703 up. */
4704
4705 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4706 abort ();
4707
4708 rel.r_offset = (htab->elf.sgot->output_section->vma
4709 + htab->elf.sgot->output_offset
4710 + (h->got.offset & ~(bfd_vma) 1));
4711
4712 /* If this is a static link, or it is a -Bsymbolic link and the
4713 symbol is defined locally or was forced to be local because
4714 of a version file, we just want to emit a RELATIVE reloc.
4715 The entry in the global offset table will already have been
4716 initialized in the relocate_section function. */
4717 if (h->def_regular
4718 && h->type == STT_GNU_IFUNC)
4719 {
4720 if (info->shared)
4721 {
4722 /* Generate R_386_GLOB_DAT. */
4723 goto do_glob_dat;
4724 }
4725 else
4726 {
4727 asection *plt;
4728
4729 if (!h->pointer_equality_needed)
4730 abort ();
4731
4732 /* For non-shared object, we can't use .got.plt, which
4733 contains the real function addres if we need pointer
4734 equality. We load the GOT entry with the PLT entry. */
4735 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4736 bfd_put_32 (output_bfd,
4737 (plt->output_section->vma
4738 + plt->output_offset + h->plt.offset),
4739 htab->elf.sgot->contents + h->got.offset);
4740 return TRUE;
4741 }
4742 }
4743 else if (info->shared
4744 && SYMBOL_REFERENCES_LOCAL (info, h))
4745 {
4746 BFD_ASSERT((h->got.offset & 1) != 0);
4747 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4748 }
4749 else
4750 {
4751 BFD_ASSERT((h->got.offset & 1) == 0);
4752 do_glob_dat:
4753 bfd_put_32 (output_bfd, (bfd_vma) 0,
4754 htab->elf.sgot->contents + h->got.offset);
4755 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4756 }
4757
4758 loc = htab->elf.srelgot->contents;
4759 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
4760 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4761 }
4762
4763 if (h->needs_copy)
4764 {
4765 Elf_Internal_Rela rel;
4766 bfd_byte *loc;
4767
4768 /* This symbol needs a copy reloc. Set it up. */
4769
4770 if (h->dynindx == -1
4771 || (h->root.type != bfd_link_hash_defined
4772 && h->root.type != bfd_link_hash_defweak)
4773 || htab->srelbss == NULL)
4774 abort ();
4775
4776 rel.r_offset = (h->root.u.def.value
4777 + h->root.u.def.section->output_section->vma
4778 + h->root.u.def.section->output_offset);
4779 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
4780 loc = htab->srelbss->contents;
4781 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
4782 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4783 }
4784
4785 return TRUE;
4786 }
4787
4788 /* Finish up local dynamic symbol handling. We set the contents of
4789 various dynamic sections here. */
4790
4791 static bfd_boolean
4792 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4793 {
4794 struct elf_link_hash_entry *h
4795 = (struct elf_link_hash_entry *) *slot;
4796 struct bfd_link_info *info
4797 = (struct bfd_link_info *) inf;
4798
4799 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4800 h, NULL);
4801 }
4802
4803 /* Used to decide how to sort relocs in an optimal manner for the
4804 dynamic linker, before writing them out. */
4805
4806 static enum elf_reloc_type_class
4807 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
4808 {
4809 switch (ELF32_R_TYPE (rela->r_info))
4810 {
4811 case R_386_RELATIVE:
4812 return reloc_class_relative;
4813 case R_386_JUMP_SLOT:
4814 return reloc_class_plt;
4815 case R_386_COPY:
4816 return reloc_class_copy;
4817 default:
4818 return reloc_class_normal;
4819 }
4820 }
4821
4822 /* Finish up the dynamic sections. */
4823
4824 static bfd_boolean
4825 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4826 struct bfd_link_info *info)
4827 {
4828 struct elf_i386_link_hash_table *htab;
4829 bfd *dynobj;
4830 asection *sdyn;
4831 const struct elf_i386_backend_data *abed;
4832
4833 htab = elf_i386_hash_table (info);
4834 if (htab == NULL)
4835 return FALSE;
4836
4837 dynobj = htab->elf.dynobj;
4838 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4839 abed = get_elf_i386_backend_data (output_bfd);
4840
4841 if (htab->elf.dynamic_sections_created)
4842 {
4843 Elf32_External_Dyn *dyncon, *dynconend;
4844
4845 if (sdyn == NULL || htab->elf.sgot == NULL)
4846 abort ();
4847
4848 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4849 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4850 for (; dyncon < dynconend; dyncon++)
4851 {
4852 Elf_Internal_Dyn dyn;
4853 asection *s;
4854
4855 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4856
4857 switch (dyn.d_tag)
4858 {
4859 default:
4860 if (abed->is_vxworks
4861 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4862 break;
4863 continue;
4864
4865 case DT_PLTGOT:
4866 s = htab->elf.sgotplt;
4867 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4868 break;
4869
4870 case DT_JMPREL:
4871 s = htab->elf.srelplt;
4872 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4873 break;
4874
4875 case DT_PLTRELSZ:
4876 s = htab->elf.srelplt;
4877 dyn.d_un.d_val = s->size;
4878 break;
4879
4880 case DT_RELSZ:
4881 /* My reading of the SVR4 ABI indicates that the
4882 procedure linkage table relocs (DT_JMPREL) should be
4883 included in the overall relocs (DT_REL). This is
4884 what Solaris does. However, UnixWare can not handle
4885 that case. Therefore, we override the DT_RELSZ entry
4886 here to make it not include the JMPREL relocs. */
4887 s = htab->elf.srelplt;
4888 if (s == NULL)
4889 continue;
4890 dyn.d_un.d_val -= s->size;
4891 break;
4892
4893 case DT_REL:
4894 /* We may not be using the standard ELF linker script.
4895 If .rel.plt is the first .rel section, we adjust
4896 DT_REL to not include it. */
4897 s = htab->elf.srelplt;
4898 if (s == NULL)
4899 continue;
4900 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4901 continue;
4902 dyn.d_un.d_ptr += s->size;
4903 break;
4904 }
4905
4906 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4907 }
4908
4909 /* Fill in the first entry in the procedure linkage table. */
4910 if (htab->elf.splt && htab->elf.splt->size > 0)
4911 {
4912 if (info->shared)
4913 {
4914 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4915 abed->plt->plt0_entry_size);
4916 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4917 abed->plt0_pad_byte,
4918 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4919 }
4920 else
4921 {
4922 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4923 abed->plt->plt0_entry_size);
4924 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4925 abed->plt0_pad_byte,
4926 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
4927 bfd_put_32 (output_bfd,
4928 (htab->elf.sgotplt->output_section->vma
4929 + htab->elf.sgotplt->output_offset
4930 + 4),
4931 htab->elf.splt->contents
4932 + abed->plt->plt0_got1_offset);
4933 bfd_put_32 (output_bfd,
4934 (htab->elf.sgotplt->output_section->vma
4935 + htab->elf.sgotplt->output_offset
4936 + 8),
4937 htab->elf.splt->contents
4938 + abed->plt->plt0_got2_offset);
4939
4940 if (abed->is_vxworks)
4941 {
4942 Elf_Internal_Rela rel;
4943
4944 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4945 On IA32 we use REL relocations so the addend goes in
4946 the PLT directly. */
4947 rel.r_offset = (htab->elf.splt->output_section->vma
4948 + htab->elf.splt->output_offset
4949 + abed->plt->plt0_got1_offset);
4950 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4951 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4952 htab->srelplt2->contents);
4953 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
4954 rel.r_offset = (htab->elf.splt->output_section->vma
4955 + htab->elf.splt->output_offset
4956 + abed->plt->plt0_got2_offset);
4957 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4958 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4959 htab->srelplt2->contents +
4960 sizeof (Elf32_External_Rel));
4961 }
4962 }
4963
4964 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4965 really seem like the right value. */
4966 elf_section_data (htab->elf.splt->output_section)
4967 ->this_hdr.sh_entsize = 4;
4968
4969 /* Correct the .rel.plt.unloaded relocations. */
4970 if (abed->is_vxworks && !info->shared)
4971 {
4972 int num_plts = (htab->elf.splt->size
4973 / abed->plt->plt_entry_size) - 1;
4974 unsigned char *p;
4975
4976 p = htab->srelplt2->contents;
4977 if (info->shared)
4978 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4979 else
4980 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4981
4982 for (; num_plts; num_plts--)
4983 {
4984 Elf_Internal_Rela rel;
4985 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4986 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4987 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4988 p += sizeof (Elf32_External_Rel);
4989
4990 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4991 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4992 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4993 p += sizeof (Elf32_External_Rel);
4994 }
4995 }
4996 }
4997 }
4998
4999 if (htab->elf.sgotplt)
5000 {
5001 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5002 {
5003 (*_bfd_error_handler)
5004 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5005 return FALSE;
5006 }
5007
5008 /* Fill in the first three entries in the global offset table. */
5009 if (htab->elf.sgotplt->size > 0)
5010 {
5011 bfd_put_32 (output_bfd,
5012 (sdyn == NULL ? 0
5013 : sdyn->output_section->vma + sdyn->output_offset),
5014 htab->elf.sgotplt->contents);
5015 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5016 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5017 }
5018
5019 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5020 }
5021
5022 /* Adjust .eh_frame for .plt section. */
5023 if (htab->plt_eh_frame != NULL
5024 && htab->plt_eh_frame->contents != NULL)
5025 {
5026 if (htab->elf.splt != NULL
5027 && htab->elf.splt->size != 0
5028 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5029 && htab->elf.splt->output_section != NULL
5030 && htab->plt_eh_frame->output_section != NULL)
5031 {
5032 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5033 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5034 + htab->plt_eh_frame->output_offset
5035 + PLT_FDE_START_OFFSET;
5036 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5037 htab->plt_eh_frame->contents
5038 + PLT_FDE_START_OFFSET);
5039 }
5040 if (htab->plt_eh_frame->sec_info_type
5041 == SEC_INFO_TYPE_EH_FRAME)
5042 {
5043 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5044 htab->plt_eh_frame,
5045 htab->plt_eh_frame->contents))
5046 return FALSE;
5047 }
5048 }
5049
5050 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5051 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5052
5053 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5054 htab_traverse (htab->loc_hash_table,
5055 elf_i386_finish_local_dynamic_symbol,
5056 info);
5057
5058 return TRUE;
5059 }
5060
5061 /* Return address for Ith PLT stub in section PLT, for relocation REL
5062 or (bfd_vma) -1 if it should not be included. */
5063
5064 static bfd_vma
5065 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
5066 const arelent *rel ATTRIBUTE_UNUSED)
5067 {
5068 return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
5069 }
5070
5071 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5072
5073 static bfd_boolean
5074 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5075 {
5076 if (h->plt.offset != (bfd_vma) -1
5077 && !h->def_regular
5078 && !h->pointer_equality_needed)
5079 return FALSE;
5080
5081 return _bfd_elf_hash_symbol (h);
5082 }
5083
5084 /* Hook called by the linker routine which adds symbols from an object
5085 file. */
5086
5087 static bfd_boolean
5088 elf_i386_add_symbol_hook (bfd * abfd,
5089 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5090 Elf_Internal_Sym * sym,
5091 const char ** namep ATTRIBUTE_UNUSED,
5092 flagword * flagsp ATTRIBUTE_UNUSED,
5093 asection ** secp ATTRIBUTE_UNUSED,
5094 bfd_vma * valp ATTRIBUTE_UNUSED)
5095 {
5096 if ((abfd->flags & DYNAMIC) == 0
5097 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5098 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5099 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5100
5101 return TRUE;
5102 }
5103
5104 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
5105 #define TARGET_LITTLE_NAME "elf32-i386"
5106 #define ELF_ARCH bfd_arch_i386
5107 #define ELF_TARGET_ID I386_ELF_DATA
5108 #define ELF_MACHINE_CODE EM_386
5109 #define ELF_MAXPAGESIZE 0x1000
5110
5111 #define elf_backend_can_gc_sections 1
5112 #define elf_backend_can_refcount 1
5113 #define elf_backend_want_got_plt 1
5114 #define elf_backend_plt_readonly 1
5115 #define elf_backend_want_plt_sym 0
5116 #define elf_backend_got_header_size 12
5117 #define elf_backend_plt_alignment 4
5118
5119 /* Support RELA for objdump of prelink objects. */
5120 #define elf_info_to_howto elf_i386_info_to_howto_rel
5121 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5122
5123 #define bfd_elf32_mkobject elf_i386_mkobject
5124
5125 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5126 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5127 #define bfd_elf32_bfd_link_hash_table_free elf_i386_link_hash_table_free
5128 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5129 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5130
5131 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5132 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5133 #define elf_backend_check_relocs elf_i386_check_relocs
5134 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5135 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5136 #define elf_backend_fake_sections elf_i386_fake_sections
5137 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5138 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5139 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5140 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
5141 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5142 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5143 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5144 #define elf_backend_relocate_section elf_i386_relocate_section
5145 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5146 #define elf_backend_always_size_sections elf_i386_always_size_sections
5147 #define elf_backend_omit_section_dynsym \
5148 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5149 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
5150 #define elf_backend_hash_symbol elf_i386_hash_symbol
5151 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5152 #undef elf_backend_post_process_headers
5153 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5154
5155 #include "elf32-target.h"
5156
5157 /* FreeBSD support. */
5158
5159 #undef TARGET_LITTLE_SYM
5160 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
5161 #undef TARGET_LITTLE_NAME
5162 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5163 #undef ELF_OSABI
5164 #define ELF_OSABI ELFOSABI_FREEBSD
5165
5166 /* The kernel recognizes executables as valid only if they carry a
5167 "FreeBSD" label in the ELF header. So we put this label on all
5168 executables and (for simplicity) also all other object files. */
5169
5170 static void
5171 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5172 {
5173 _bfd_elf_set_osabi (abfd, info);
5174
5175 #ifdef OLD_FREEBSD_ABI_LABEL
5176 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5177 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5178 #endif
5179 }
5180
5181 #undef elf_backend_post_process_headers
5182 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5183 #undef elf32_bed
5184 #define elf32_bed elf32_i386_fbsd_bed
5185
5186 #undef elf_backend_add_symbol_hook
5187
5188 #include "elf32-target.h"
5189
5190 /* Solaris 2. */
5191
5192 #undef TARGET_LITTLE_SYM
5193 #define TARGET_LITTLE_SYM bfd_elf32_i386_sol2_vec
5194 #undef TARGET_LITTLE_NAME
5195 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5196
5197 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5198 objects won't be recognized. */
5199 #undef ELF_OSABI
5200
5201 #undef elf32_bed
5202 #define elf32_bed elf32_i386_sol2_bed
5203
5204 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5205 boundary. */
5206 #undef elf_backend_static_tls_alignment
5207 #define elf_backend_static_tls_alignment 8
5208
5209 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5210
5211 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5212 File, p.63. */
5213 #undef elf_backend_want_plt_sym
5214 #define elf_backend_want_plt_sym 1
5215
5216 #include "elf32-target.h"
5217
5218 /* Native Client support. */
5219
5220 #undef TARGET_LITTLE_SYM
5221 #define TARGET_LITTLE_SYM bfd_elf32_i386_nacl_vec
5222 #undef TARGET_LITTLE_NAME
5223 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
5224 #undef elf32_bed
5225 #define elf32_bed elf32_i386_nacl_bed
5226
5227 #undef ELF_MAXPAGESIZE
5228 #define ELF_MAXPAGESIZE 0x10000
5229
5230 /* Restore defaults. */
5231 #undef ELF_OSABI
5232 #undef elf_backend_want_plt_sym
5233 #define elf_backend_want_plt_sym 0
5234 #undef elf_backend_post_process_headers
5235 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5236 #undef elf_backend_static_tls_alignment
5237
5238 /* NaCl uses substantially different PLT entries for the same effects. */
5239
5240 #undef elf_backend_plt_alignment
5241 #define elf_backend_plt_alignment 5
5242 #define NACL_PLT_ENTRY_SIZE 64
5243 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5244
5245 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5246 {
5247 0xff, 0x35, /* pushl contents of address */
5248 0, 0, 0, 0, /* replaced with address of .got + 4. */
5249 0x8b, 0x0d, /* movl contents of address, %ecx */
5250 0, 0, 0, 0, /* replaced with address of .got + 8. */
5251 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5252 0xff, 0xe1 /* jmp *%ecx */
5253 };
5254
5255 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5256 {
5257 0x8b, 0x0d, /* movl contents of address, %ecx */
5258 0, 0, 0, 0, /* replaced with GOT slot address. */
5259 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5260 0xff, 0xe1, /* jmp *%ecx */
5261
5262 /* Pad to the next 32-byte boundary with nop instructions. */
5263 0x90,
5264 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5265 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5266
5267 /* Lazy GOT entries point here (32-byte aligned). */
5268 0x68, /* pushl immediate */
5269 0, 0, 0, 0, /* replaced with reloc offset. */
5270 0xe9, /* jmp relative */
5271 0, 0, 0, 0, /* replaced with offset to .plt. */
5272
5273 /* Pad to the next 32-byte boundary with nop instructions. */
5274 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5275 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5276 0x90, 0x90
5277 };
5278
5279 static const bfd_byte
5280 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5281 {
5282 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
5283 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
5284 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
5285 0xff, 0xe1, /* jmp *%ecx */
5286
5287 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5288 so pad to that size with nop instructions. */
5289 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5290 };
5291
5292 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5293 {
5294 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
5295 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
5296 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
5297 0xff, 0xe1, /* jmp *%ecx */
5298
5299 /* Pad to the next 32-byte boundary with nop instructions. */
5300 0x90,
5301 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5302 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5303
5304 /* Lazy GOT entries point here (32-byte aligned). */
5305 0x68, /* pushl immediate */
5306 0, 0, 0, 0, /* replaced with offset into relocation table. */
5307 0xe9, /* jmp relative */
5308 0, 0, 0, 0, /* replaced with offset to start of .plt. */
5309
5310 /* Pad to the next 32-byte boundary with nop instructions. */
5311 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5312 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5313 0x90, 0x90
5314 };
5315
5316 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5317 {
5318 #if (PLT_CIE_LENGTH != 20 \
5319 || PLT_FDE_LENGTH != 36 \
5320 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5321 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5322 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5323 #endif
5324 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5325 0, 0, 0, 0, /* CIE ID */
5326 1, /* CIE version */
5327 'z', 'R', 0, /* Augmentation string */
5328 1, /* Code alignment factor */
5329 0x7c, /* Data alignment factor: -4 */
5330 8, /* Return address column */
5331 1, /* Augmentation size */
5332 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5333 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5334 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
5335 DW_CFA_nop, DW_CFA_nop,
5336
5337 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5338 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5339 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
5340 0, 0, 0, 0, /* .plt size goes here */
5341 0, /* Augmentation size */
5342 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
5343 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5344 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
5345 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5346 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5347 13, /* Block length */
5348 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
5349 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
5350 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5351 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5352 DW_CFA_nop, DW_CFA_nop
5353 };
5354
5355 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5356 {
5357 elf_i386_nacl_plt0_entry, /* plt0_entry */
5358 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
5359 2, /* plt0_got1_offset */
5360 8, /* plt0_got2_offset */
5361 elf_i386_nacl_plt_entry, /* plt_entry */
5362 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5363 2, /* plt_got_offset */
5364 33, /* plt_reloc_offset */
5365 38, /* plt_plt_offset */
5366 32, /* plt_lazy_offset */
5367 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
5368 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
5369 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
5370 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5371 };
5372
5373 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5374 {
5375 &elf_i386_nacl_plt, /* plt */
5376 0x90, /* plt0_pad_byte: nop insn */
5377 0, /* is_vxworks */
5378 };
5379
5380 #undef elf_backend_arch_data
5381 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
5382
5383 #undef elf_backend_modify_segment_map
5384 #define elf_backend_modify_segment_map nacl_modify_segment_map
5385 #undef elf_backend_modify_program_headers
5386 #define elf_backend_modify_program_headers nacl_modify_program_headers
5387
5388 #include "elf32-target.h"
5389
5390 /* Restore defaults. */
5391 #undef elf_backend_modify_segment_map
5392 #undef elf_backend_modify_program_headers
5393
5394 /* VxWorks support. */
5395
5396 #undef TARGET_LITTLE_SYM
5397 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
5398 #undef TARGET_LITTLE_NAME
5399 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
5400 #undef ELF_OSABI
5401 #undef elf_backend_plt_alignment
5402 #define elf_backend_plt_alignment 4
5403
5404 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5405 {
5406 &elf_i386_plt, /* plt */
5407 0x90, /* plt0_pad_byte */
5408 1, /* is_vxworks */
5409 };
5410
5411 #undef elf_backend_arch_data
5412 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
5413
5414 #undef elf_backend_relocs_compatible
5415 #undef elf_backend_post_process_headers
5416 #undef elf_backend_add_symbol_hook
5417 #define elf_backend_add_symbol_hook \
5418 elf_vxworks_add_symbol_hook
5419 #undef elf_backend_link_output_symbol_hook
5420 #define elf_backend_link_output_symbol_hook \
5421 elf_vxworks_link_output_symbol_hook
5422 #undef elf_backend_emit_relocs
5423 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
5424 #undef elf_backend_final_write_processing
5425 #define elf_backend_final_write_processing \
5426 elf_vxworks_final_write_processing
5427 #undef elf_backend_static_tls_alignment
5428
5429 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5430 define it. */
5431 #undef elf_backend_want_plt_sym
5432 #define elf_backend_want_plt_sym 1
5433
5434 #undef elf32_bed
5435 #define elf32_bed elf32_i386_vxworks_bed
5436
5437 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.215046 seconds and 4 git commands to generate.