?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include/
[binutils.git] / bfd / elf32-i386.c
blob9e96e215fb90e59fe6b184dff7133c208b529134
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 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
29
30 /* 386 uses REL relocations instead of RELA. */
31 #define USE_REL 1
32
33 #include "elf/i386.h"
34
35 static reloc_howto_type elf_howto_table[]=
36 {
37 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
38 bfd_elf_generic_reloc, "R_386_NONE",
39 TRUE, 0x00000000, 0x00000000, FALSE),
40 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
41 bfd_elf_generic_reloc, "R_386_32",
42 TRUE, 0xffffffff, 0xffffffff, FALSE),
43 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
44 bfd_elf_generic_reloc, "R_386_PC32",
45 TRUE, 0xffffffff, 0xffffffff, TRUE),
46 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
47 bfd_elf_generic_reloc, "R_386_GOT32",
48 TRUE, 0xffffffff, 0xffffffff, FALSE),
49 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
50 bfd_elf_generic_reloc, "R_386_PLT32",
51 TRUE, 0xffffffff, 0xffffffff, TRUE),
52 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
53 bfd_elf_generic_reloc, "R_386_COPY",
54 TRUE, 0xffffffff, 0xffffffff, FALSE),
55 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
56 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
57 TRUE, 0xffffffff, 0xffffffff, FALSE),
58 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
59 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
60 TRUE, 0xffffffff, 0xffffffff, FALSE),
61 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "R_386_RELATIVE",
63 TRUE, 0xffffffff, 0xffffffff, FALSE),
64 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
65 bfd_elf_generic_reloc, "R_386_GOTOFF",
66 TRUE, 0xffffffff, 0xffffffff, FALSE),
67 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
68 bfd_elf_generic_reloc, "R_386_GOTPC",
69 TRUE, 0xffffffff, 0xffffffff, TRUE),
70
71 /* We have a gap in the reloc numbers here.
72 R_386_standard counts the number up to this point, and
73 R_386_ext_offset is the value to subtract from a reloc type of
74 R_386_16 thru R_386_PC8 to form an index into this table. */
75 #define R_386_standard (R_386_GOTPC + 1)
76 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
77
78 /* These relocs are a GNU extension. */
79 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
80 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
81 TRUE, 0xffffffff, 0xffffffff, FALSE),
82 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_386_TLS_IE",
84 TRUE, 0xffffffff, 0xffffffff, FALSE),
85 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
86 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
87 TRUE, 0xffffffff, 0xffffffff, FALSE),
88 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_386_TLS_LE",
90 TRUE, 0xffffffff, 0xffffffff, FALSE),
91 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
92 bfd_elf_generic_reloc, "R_386_TLS_GD",
93 TRUE, 0xffffffff, 0xffffffff, FALSE),
94 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_386_TLS_LDM",
96 TRUE, 0xffffffff, 0xffffffff, FALSE),
97 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_386_16",
99 TRUE, 0xffff, 0xffff, FALSE),
100 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
101 bfd_elf_generic_reloc, "R_386_PC16",
102 TRUE, 0xffff, 0xffff, TRUE),
103 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_386_8",
105 TRUE, 0xff, 0xff, FALSE),
106 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
107 bfd_elf_generic_reloc, "R_386_PC8",
108 TRUE, 0xff, 0xff, TRUE),
109
110 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
111 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
112 /* These are common with Solaris TLS implementation. */
113 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
115 TRUE, 0xffffffff, 0xffffffff, FALSE),
116 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
123 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
126 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
127 TRUE, 0xffffffff, 0xffffffff, FALSE),
128 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
129 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
130 TRUE, 0xffffffff, 0xffffffff, FALSE),
131 EMPTY_HOWTO (38),
132 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
133 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
134 TRUE, 0xffffffff, 0xffffffff, FALSE),
135 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
136 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
137 FALSE, 0, 0, FALSE),
138 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_DESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141
142 /* Another gap. */
143 #define R_386_tls (R_386_TLS_DESC + 1 - R_386_tls_offset)
144 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
145
146 /* GNU extension to record C++ vtable hierarchy. */
147 HOWTO (R_386_GNU_VTINHERIT, /* type */
148 0, /* rightshift */
149 2, /* size (0 = byte, 1 = short, 2 = long) */
150 0, /* bitsize */
151 FALSE, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_dont, /* complain_on_overflow */
154 NULL, /* special_function */
155 "R_386_GNU_VTINHERIT", /* name */
156 FALSE, /* partial_inplace */
157 0, /* src_mask */
158 0, /* dst_mask */
159 FALSE), /* pcrel_offset */
160
161 /* GNU extension to record C++ vtable member usage. */
162 HOWTO (R_386_GNU_VTENTRY, /* type */
163 0, /* rightshift */
164 2, /* size (0 = byte, 1 = short, 2 = long) */
165 0, /* bitsize */
166 FALSE, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_dont, /* complain_on_overflow */
169 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
170 "R_386_GNU_VTENTRY", /* name */
171 FALSE, /* partial_inplace */
172 0, /* src_mask */
173 0, /* dst_mask */
174 FALSE) /* pcrel_offset */
175
176 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
177
178 };
179
180 #ifdef DEBUG_GEN_RELOC
181 #define TRACE(str) \
182 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
183 #else
184 #define TRACE(str)
185 #endif
186
187 static reloc_howto_type *
188 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
189 bfd_reloc_code_real_type code)
190 {
191 switch (code)
192 {
193 case BFD_RELOC_NONE:
194 TRACE ("BFD_RELOC_NONE");
195 return &elf_howto_table[R_386_NONE];
196
197 case BFD_RELOC_32:
198 TRACE ("BFD_RELOC_32");
199 return &elf_howto_table[R_386_32];
200
201 case BFD_RELOC_CTOR:
202 TRACE ("BFD_RELOC_CTOR");
203 return &elf_howto_table[R_386_32];
204
205 case BFD_RELOC_32_PCREL:
206 TRACE ("BFD_RELOC_PC32");
207 return &elf_howto_table[R_386_PC32];
208
209 case BFD_RELOC_386_GOT32:
210 TRACE ("BFD_RELOC_386_GOT32");
211 return &elf_howto_table[R_386_GOT32];
212
213 case BFD_RELOC_386_PLT32:
214 TRACE ("BFD_RELOC_386_PLT32");
215 return &elf_howto_table[R_386_PLT32];
216
217 case BFD_RELOC_386_COPY:
218 TRACE ("BFD_RELOC_386_COPY");
219 return &elf_howto_table[R_386_COPY];
220
221 case BFD_RELOC_386_GLOB_DAT:
222 TRACE ("BFD_RELOC_386_GLOB_DAT");
223 return &elf_howto_table[R_386_GLOB_DAT];
224
225 case BFD_RELOC_386_JUMP_SLOT:
226 TRACE ("BFD_RELOC_386_JUMP_SLOT");
227 return &elf_howto_table[R_386_JUMP_SLOT];
228
229 case BFD_RELOC_386_RELATIVE:
230 TRACE ("BFD_RELOC_386_RELATIVE");
231 return &elf_howto_table[R_386_RELATIVE];
232
233 case BFD_RELOC_386_GOTOFF:
234 TRACE ("BFD_RELOC_386_GOTOFF");
235 return &elf_howto_table[R_386_GOTOFF];
236
237 case BFD_RELOC_386_GOTPC:
238 TRACE ("BFD_RELOC_386_GOTPC");
239 return &elf_howto_table[R_386_GOTPC];
240
241 /* These relocs are a GNU extension. */
242 case BFD_RELOC_386_TLS_TPOFF:
243 TRACE ("BFD_RELOC_386_TLS_TPOFF");
244 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
245
246 case BFD_RELOC_386_TLS_IE:
247 TRACE ("BFD_RELOC_386_TLS_IE");
248 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
249
250 case BFD_RELOC_386_TLS_GOTIE:
251 TRACE ("BFD_RELOC_386_TLS_GOTIE");
252 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
253
254 case BFD_RELOC_386_TLS_LE:
255 TRACE ("BFD_RELOC_386_TLS_LE");
256 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
257
258 case BFD_RELOC_386_TLS_GD:
259 TRACE ("BFD_RELOC_386_TLS_GD");
260 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
261
262 case BFD_RELOC_386_TLS_LDM:
263 TRACE ("BFD_RELOC_386_TLS_LDM");
264 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
265
266 case BFD_RELOC_16:
267 TRACE ("BFD_RELOC_16");
268 return &elf_howto_table[R_386_16 - R_386_ext_offset];
269
270 case BFD_RELOC_16_PCREL:
271 TRACE ("BFD_RELOC_16_PCREL");
272 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
273
274 case BFD_RELOC_8:
275 TRACE ("BFD_RELOC_8");
276 return &elf_howto_table[R_386_8 - R_386_ext_offset];
277
278 case BFD_RELOC_8_PCREL:
279 TRACE ("BFD_RELOC_8_PCREL");
280 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
281
282 /* Common with Sun TLS implementation. */
283 case BFD_RELOC_386_TLS_LDO_32:
284 TRACE ("BFD_RELOC_386_TLS_LDO_32");
285 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
286
287 case BFD_RELOC_386_TLS_IE_32:
288 TRACE ("BFD_RELOC_386_TLS_IE_32");
289 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
290
291 case BFD_RELOC_386_TLS_LE_32:
292 TRACE ("BFD_RELOC_386_TLS_LE_32");
293 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
294
295 case BFD_RELOC_386_TLS_DTPMOD32:
296 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
297 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
298
299 case BFD_RELOC_386_TLS_DTPOFF32:
300 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
301 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
302
303 case BFD_RELOC_386_TLS_TPOFF32:
304 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
305 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
306
307 case BFD_RELOC_386_TLS_GOTDESC:
308 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
309 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
310
311 case BFD_RELOC_386_TLS_DESC_CALL:
312 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
313 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
314
315 case BFD_RELOC_386_TLS_DESC:
316 TRACE ("BFD_RELOC_386_TLS_DESC");
317 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
318
319 case BFD_RELOC_VTABLE_INHERIT:
320 TRACE ("BFD_RELOC_VTABLE_INHERIT");
321 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
322
323 case BFD_RELOC_VTABLE_ENTRY:
324 TRACE ("BFD_RELOC_VTABLE_ENTRY");
325 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
326
327 default:
328 break;
329 }
330
331 TRACE ("Unknown");
332 return 0;
333 }
334
335 static reloc_howto_type *
336 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
337 const char *r_name)
338 {
339 unsigned int i;
340
341 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
342 if (elf_howto_table[i].name != NULL
343 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
344 return &elf_howto_table[i];
345
346 return NULL;
347 }
348
349 static reloc_howto_type *
350 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
351 {
352 unsigned int indx;
353
354 if ((indx = r_type) >= R_386_standard
355 && ((indx = r_type - R_386_ext_offset) - R_386_standard
356 >= R_386_ext - R_386_standard)
357 && ((indx = r_type - R_386_tls_offset) - R_386_ext
358 >= R_386_tls - R_386_ext)
359 && ((indx = r_type - R_386_vt_offset) - R_386_tls
360 >= R_386_vt - R_386_tls))
361 {
362 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
363 abfd, (int) r_type);
364 indx = R_386_NONE;
365 }
366 BFD_ASSERT (elf_howto_table [indx].type == r_type);
367 return &elf_howto_table[indx];
368 }
369
370 static void
371 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
372 arelent *cache_ptr,
373 Elf_Internal_Rela *dst)
374 {
375 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
376 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
377 }
378
379 /* Return whether a symbol name implies a local label. The UnixWare
380 2.1 cc generates temporary symbols that start with .X, so we
381 recognize them here. FIXME: do other SVR4 compilers also use .X?.
382 If so, we should move the .X recognition into
383 _bfd_elf_is_local_label_name. */
384
385 static bfd_boolean
386 elf_i386_is_local_label_name (bfd *abfd, const char *name)
387 {
388 if (name[0] == '.' && name[1] == 'X')
389 return TRUE;
390
391 return _bfd_elf_is_local_label_name (abfd, name);
392 }
393 \f
394 /* Support for core dump NOTE sections. */
395
396 static bfd_boolean
397 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
398 {
399 int offset;
400 size_t size;
401
402 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
403 {
404 int pr_version = bfd_get_32 (abfd, note->descdata);
405
406 if (pr_version != 1)
407 return FALSE;
408
409 /* pr_cursig */
410 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
411
412 /* pr_pid */
413 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
414
415 /* pr_reg */
416 offset = 28;
417 size = bfd_get_32 (abfd, note->descdata + 8);
418 }
419 else
420 {
421 switch (note->descsz)
422 {
423 default:
424 return FALSE;
425
426 case 144: /* Linux/i386 */
427 /* pr_cursig */
428 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
429
430 /* pr_pid */
431 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
432
433 /* pr_reg */
434 offset = 72;
435 size = 68;
436
437 break;
438 }
439 }
440
441 /* Make a ".reg/999" section. */
442 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
443 size, note->descpos + offset);
444 }
445
446 static bfd_boolean
447 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
448 {
449 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
450 {
451 int pr_version = bfd_get_32 (abfd, note->descdata);
452
453 if (pr_version != 1)
454 return FALSE;
455
456 elf_tdata (abfd)->core_program
457 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
458 elf_tdata (abfd)->core_command
459 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
460 }
461 else
462 {
463 switch (note->descsz)
464 {
465 default:
466 return FALSE;
467
468 case 124: /* Linux/i386 elf_prpsinfo. */
469 elf_tdata (abfd)->core_program
470 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
471 elf_tdata (abfd)->core_command
472 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
473 }
474 }
475
476 /* Note that for some reason, a spurious space is tacked
477 onto the end of the args in some (at least one anyway)
478 implementations, so strip it off if it exists. */
479 {
480 char *command = elf_tdata (abfd)->core_command;
481 int n = strlen (command);
482
483 if (0 < n && command[n - 1] == ' ')
484 command[n - 1] = '\0';
485 }
486
487 return TRUE;
488 }
489 \f
490 /* Functions for the i386 ELF linker.
491
492 In order to gain some understanding of code in this file without
493 knowing all the intricate details of the linker, note the
494 following:
495
496 Functions named elf_i386_* are called by external routines, other
497 functions are only called locally. elf_i386_* functions appear
498 in this file more or less in the order in which they are called
499 from external routines. eg. elf_i386_check_relocs is called
500 early in the link process, elf_i386_finish_dynamic_sections is
501 one of the last functions. */
502
503
504 /* The name of the dynamic interpreter. This is put in the .interp
505 section. */
506
507 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
508
509 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
510 copying dynamic variables from a shared lib into an app's dynbss
511 section, and instead use a dynamic relocation to point into the
512 shared lib. */
513 #define ELIMINATE_COPY_RELOCS 1
514
515 /* The size in bytes of an entry in the procedure linkage table. */
516
517 #define PLT_ENTRY_SIZE 16
518
519 /* The first entry in an absolute procedure linkage table looks like
520 this. See the SVR4 ABI i386 supplement to see how this works.
521 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
522
523 static const bfd_byte elf_i386_plt0_entry[12] =
524 {
525 0xff, 0x35, /* pushl contents of address */
526 0, 0, 0, 0, /* replaced with address of .got + 4. */
527 0xff, 0x25, /* jmp indirect */
528 0, 0, 0, 0 /* replaced with address of .got + 8. */
529 };
530
531 /* Subsequent entries in an absolute procedure linkage table look like
532 this. */
533
534 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
535 {
536 0xff, 0x25, /* jmp indirect */
537 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
538 0x68, /* pushl immediate */
539 0, 0, 0, 0, /* replaced with offset into relocation table. */
540 0xe9, /* jmp relative */
541 0, 0, 0, 0 /* replaced with offset to start of .plt. */
542 };
543
544 /* The first entry in a PIC procedure linkage table look like this.
545 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
546
547 static const bfd_byte elf_i386_pic_plt0_entry[12] =
548 {
549 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
550 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
551 };
552
553 /* Subsequent entries in a PIC procedure linkage table look like this. */
554
555 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
556 {
557 0xff, 0xa3, /* jmp *offset(%ebx) */
558 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
559 0x68, /* pushl immediate */
560 0, 0, 0, 0, /* replaced with offset into relocation table. */
561 0xe9, /* jmp relative */
562 0, 0, 0, 0 /* replaced with offset to start of .plt. */
563 };
564
565 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
566 for the PLTResolve stub and then for each PLT entry. */
567 #define PLTRESOLVE_RELOCS_SHLIB 0
568 #define PLTRESOLVE_RELOCS 2
569 #define PLT_NON_JUMP_SLOT_RELOCS 2
570
571 /* The i386 linker needs to keep track of the number of relocs that it
572 decides to copy as dynamic relocs in check_relocs for each symbol.
573 This is so that it can later discard them if they are found to be
574 unnecessary. We store the information in a field extending the
575 regular ELF linker hash table. */
576
577 struct elf_i386_dyn_relocs
578 {
579 struct elf_i386_dyn_relocs *next;
580
581 /* The input section of the reloc. */
582 asection *sec;
583
584 /* Total number of relocs copied for the input section. */
585 bfd_size_type count;
586
587 /* Number of pc-relative relocs copied for the input section. */
588 bfd_size_type pc_count;
589 };
590
591 /* i386 ELF linker hash entry. */
592
593 struct elf_i386_link_hash_entry
594 {
595 struct elf_link_hash_entry elf;
596
597 /* Track dynamic relocs copied for this symbol. */
598 struct elf_i386_dyn_relocs *dyn_relocs;
599
600 #define GOT_UNKNOWN 0
601 #define GOT_NORMAL 1
602 #define GOT_TLS_GD 2
603 #define GOT_TLS_IE 4
604 #define GOT_TLS_IE_POS 5
605 #define GOT_TLS_IE_NEG 6
606 #define GOT_TLS_IE_BOTH 7
607 #define GOT_TLS_GDESC 8
608 #define GOT_TLS_GD_BOTH_P(type) \
609 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
610 #define GOT_TLS_GD_P(type) \
611 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
612 #define GOT_TLS_GDESC_P(type) \
613 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
614 #define GOT_TLS_GD_ANY_P(type) \
615 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
616 unsigned char tls_type;
617
618 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
619 starting at the end of the jump table. */
620 bfd_vma tlsdesc_got;
621 };
622
623 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
624
625 struct elf_i386_obj_tdata
626 {
627 struct elf_obj_tdata root;
628
629 /* tls_type for each local got entry. */
630 char *local_got_tls_type;
631
632 /* GOTPLT entries for TLS descriptors. */
633 bfd_vma *local_tlsdesc_gotent;
634 };
635
636 #define elf_i386_tdata(abfd) \
637 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
638
639 #define elf_i386_local_got_tls_type(abfd) \
640 (elf_i386_tdata (abfd)->local_got_tls_type)
641
642 #define elf_i386_local_tlsdesc_gotent(abfd) \
643 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
644
645 #define is_i386_elf(bfd) \
646 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
647 && elf_tdata (bfd) != NULL \
648 && elf_object_id (bfd) == I386_ELF_TDATA)
649
650 static bfd_boolean
651 elf_i386_mkobject (bfd *abfd)
652 {
653 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
654 I386_ELF_TDATA);
655 }
656
657 /* i386 ELF linker hash table. */
658
659 struct elf_i386_link_hash_table
660 {
661 struct elf_link_hash_table elf;
662
663 /* Short-cuts to get to dynamic linker sections. */
664 asection *sgot;
665 asection *sgotplt;
666 asection *srelgot;
667 asection *splt;
668 asection *srelplt;
669 asection *sdynbss;
670 asection *srelbss;
671
672 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
673 asection *srelplt2;
674
675 /* True if the target system is VxWorks. */
676 int is_vxworks;
677
678 /* Value used to fill the last word of the first plt entry. */
679 bfd_byte plt0_pad_byte;
680
681 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
682 bfd_vma next_tls_desc_index;
683
684 union {
685 bfd_signed_vma refcount;
686 bfd_vma offset;
687 } tls_ldm_got;
688
689 /* The amount of space used by the reserved portion of the sgotplt
690 section, plus whatever space is used by the jump slots. */
691 bfd_vma sgotplt_jump_table_size;
692
693 /* Small local sym to section mapping cache. */
694 struct sym_sec_cache sym_sec;
695
696 /* _TLS_MODULE_BASE_ symbol. */
697 struct bfd_link_hash_entry *tls_module_base;
698 };
699
700 /* Get the i386 ELF linker hash table from a link_info structure. */
701
702 #define elf_i386_hash_table(p) \
703 ((struct elf_i386_link_hash_table *) ((p)->hash))
704
705 #define elf_i386_compute_jump_table_size(htab) \
706 ((htab)->next_tls_desc_index * 4)
707
708 /* Create an entry in an i386 ELF linker hash table. */
709
710 static struct bfd_hash_entry *
711 link_hash_newfunc (struct bfd_hash_entry *entry,
712 struct bfd_hash_table *table,
713 const char *string)
714 {
715 /* Allocate the structure if it has not already been allocated by a
716 subclass. */
717 if (entry == NULL)
718 {
719 entry = bfd_hash_allocate (table,
720 sizeof (struct elf_i386_link_hash_entry));
721 if (entry == NULL)
722 return entry;
723 }
724
725 /* Call the allocation method of the superclass. */
726 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
727 if (entry != NULL)
728 {
729 struct elf_i386_link_hash_entry *eh;
730
731 eh = (struct elf_i386_link_hash_entry *) entry;
732 eh->dyn_relocs = NULL;
733 eh->tls_type = GOT_UNKNOWN;
734 eh->tlsdesc_got = (bfd_vma) -1;
735 }
736
737 return entry;
738 }
739
740 /* Create an i386 ELF linker hash table. */
741
742 static struct bfd_link_hash_table *
743 elf_i386_link_hash_table_create (bfd *abfd)
744 {
745 struct elf_i386_link_hash_table *ret;
746 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
747
748 ret = bfd_malloc (amt);
749 if (ret == NULL)
750 return NULL;
751
752 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
753 sizeof (struct elf_i386_link_hash_entry)))
754 {
755 free (ret);
756 return NULL;
757 }
758
759 ret->sgot = NULL;
760 ret->sgotplt = NULL;
761 ret->srelgot = NULL;
762 ret->splt = NULL;
763 ret->srelplt = NULL;
764 ret->sdynbss = NULL;
765 ret->srelbss = NULL;
766 ret->tls_ldm_got.refcount = 0;
767 ret->next_tls_desc_index = 0;
768 ret->sgotplt_jump_table_size = 0;
769 ret->sym_sec.abfd = NULL;
770 ret->is_vxworks = 0;
771 ret->srelplt2 = NULL;
772 ret->plt0_pad_byte = 0;
773 ret->tls_module_base = NULL;
774
775 return &ret->elf.root;
776 }
777
778 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
779 shortcuts to them in our hash table. */
780
781 static bfd_boolean
782 create_got_section (bfd *dynobj, struct bfd_link_info *info)
783 {
784 struct elf_i386_link_hash_table *htab;
785
786 if (! _bfd_elf_create_got_section (dynobj, info))
787 return FALSE;
788
789 htab = elf_i386_hash_table (info);
790 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
791 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
792 if (!htab->sgot || !htab->sgotplt)
793 abort ();
794
795 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
796 (SEC_ALLOC | SEC_LOAD
797 | SEC_HAS_CONTENTS
798 | SEC_IN_MEMORY
799 | SEC_LINKER_CREATED
800 | SEC_READONLY));
801 if (htab->srelgot == NULL
802 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
803 return FALSE;
804 return TRUE;
805 }
806
807 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
808 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
809 hash table. */
810
811 static bfd_boolean
812 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
813 {
814 struct elf_i386_link_hash_table *htab;
815
816 htab = elf_i386_hash_table (info);
817 if (!htab->sgot && !create_got_section (dynobj, info))
818 return FALSE;
819
820 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
821 return FALSE;
822
823 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
824 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
825 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
826 if (!info->shared)
827 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
828
829 if (!htab->splt || !htab->srelplt || !htab->sdynbss
830 || (!info->shared && !htab->srelbss))
831 abort ();
832
833 if (htab->is_vxworks
834 && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
835 return FALSE;
836
837 return TRUE;
838 }
839
840 /* Copy the extra info we tack onto an elf_link_hash_entry. */
841
842 static void
843 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
844 struct elf_link_hash_entry *dir,
845 struct elf_link_hash_entry *ind)
846 {
847 struct elf_i386_link_hash_entry *edir, *eind;
848
849 edir = (struct elf_i386_link_hash_entry *) dir;
850 eind = (struct elf_i386_link_hash_entry *) ind;
851
852 if (eind->dyn_relocs != NULL)
853 {
854 if (edir->dyn_relocs != NULL)
855 {
856 struct elf_i386_dyn_relocs **pp;
857 struct elf_i386_dyn_relocs *p;
858
859 /* Add reloc counts against the indirect sym to the direct sym
860 list. Merge any entries against the same section. */
861 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
862 {
863 struct elf_i386_dyn_relocs *q;
864
865 for (q = edir->dyn_relocs; q != NULL; q = q->next)
866 if (q->sec == p->sec)
867 {
868 q->pc_count += p->pc_count;
869 q->count += p->count;
870 *pp = p->next;
871 break;
872 }
873 if (q == NULL)
874 pp = &p->next;
875 }
876 *pp = edir->dyn_relocs;
877 }
878
879 edir->dyn_relocs = eind->dyn_relocs;
880 eind->dyn_relocs = NULL;
881 }
882
883 if (ind->root.type == bfd_link_hash_indirect
884 && dir->got.refcount <= 0)
885 {
886 edir->tls_type = eind->tls_type;
887 eind->tls_type = GOT_UNKNOWN;
888 }
889
890 if (ELIMINATE_COPY_RELOCS
891 && ind->root.type != bfd_link_hash_indirect
892 && dir->dynamic_adjusted)
893 {
894 /* If called to transfer flags for a weakdef during processing
895 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
896 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
897 dir->ref_dynamic |= ind->ref_dynamic;
898 dir->ref_regular |= ind->ref_regular;
899 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
900 dir->needs_plt |= ind->needs_plt;
901 dir->pointer_equality_needed |= ind->pointer_equality_needed;
902 }
903 else
904 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
905 }
906
907 typedef union
908 {
909 unsigned char c[2];
910 uint16_t i;
911 }
912 i386_opcode16;
913
914 /* Return TRUE if the TLS access code sequence support transition
915 from R_TYPE. */
916
917 static bfd_boolean
918 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
919 bfd_byte *contents,
920 Elf_Internal_Shdr *symtab_hdr,
921 struct elf_link_hash_entry **sym_hashes,
922 unsigned int r_type,
923 const Elf_Internal_Rela *rel,
924 const Elf_Internal_Rela *relend)
925 {
926 unsigned int val, type;
927 unsigned long r_symndx;
928 struct elf_link_hash_entry *h;
929 bfd_vma offset;
930
931 /* Get the section contents. */
932 if (contents == NULL)
933 {
934 if (elf_section_data (sec)->this_hdr.contents != NULL)
935 contents = elf_section_data (sec)->this_hdr.contents;
936 else
937 {
938 /* FIXME: How to better handle error condition? */
939 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
940 return FALSE;
941
942 /* Cache the section contents for elf_link_input_bfd. */
943 elf_section_data (sec)->this_hdr.contents = contents;
944 }
945 }
946
947 offset = rel->r_offset;
948 switch (r_type)
949 {
950 case R_386_TLS_GD:
951 case R_386_TLS_LDM:
952 if (offset < 2 || (rel + 1) >= relend)
953 return FALSE;
954
955 type = bfd_get_8 (abfd, contents + offset - 2);
956 if (r_type == R_386_TLS_GD)
957 {
958 /* Check transition from LD access model. Only
959 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
960 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
961 can transit to different access model. */
962 if ((offset + 10) > sec->size ||
963 (type != 0x8d && type != 0x04))
964 return FALSE;
965
966 val = bfd_get_8 (abfd, contents + offset - 1);
967 if (type == 0x04)
968 {
969 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
970 if (offset < 3)
971 return FALSE;
972
973 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
974 return FALSE;
975
976 if ((val & 0xc7) != 0x05 || val == (4 << 3))
977 return FALSE;
978 }
979 else
980 {
981 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
982 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
983 return FALSE;
984
985 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
986 return FALSE;
987 }
988 }
989 else
990 {
991 /* Check transition from LD access model. Only
992 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
993 can transit to different access model. */
994 if (type != 0x8d || (offset + 9) > sec->size)
995 return FALSE;
996
997 val = bfd_get_8 (abfd, contents + offset - 1);
998 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
999 return FALSE;
1000 }
1001
1002 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1003 return FALSE;
1004
1005 r_symndx = ELF32_R_SYM (rel[1].r_info);
1006 if (r_symndx < symtab_hdr->sh_info)
1007 return FALSE;
1008
1009 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1010 return (h != NULL
1011 && h->root.root.string != NULL
1012 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1013 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1014 && (strcmp (h->root.root.string, "___tls_get_addr") == 0));
1015
1016 case R_386_TLS_IE:
1017 /* Check transition from IE access model:
1018 movl foo@indntpoff(%rip), %eax
1019 movl foo@indntpoff(%rip), %reg
1020 addl foo@indntpoff(%rip), %reg
1021 */
1022
1023 if (offset < 1 || (offset + 4) > sec->size)
1024 return FALSE;
1025
1026 /* Check "movl foo@tpoff(%rip), %eax" first. */
1027 val = bfd_get_8 (abfd, contents + offset - 1);
1028 if (val == 0xa1)
1029 return TRUE;
1030
1031 if (offset < 2)
1032 return FALSE;
1033
1034 /* Check movl|addl foo@tpoff(%rip), %reg. */
1035 type = bfd_get_8 (abfd, contents + offset - 2);
1036 return ((type == 0x8b || type == 0x03)
1037 && (val & 0xc7) == 0x05);
1038
1039 case R_386_TLS_GOTIE:
1040 case R_386_TLS_IE_32:
1041 /* Check transition from {IE_32,GOTIE} access model:
1042 subl foo@{tpoff,gontoff}(%reg1), %reg2
1043 movl foo@{tpoff,gontoff}(%reg1), %reg2
1044 addl foo@{tpoff,gontoff}(%reg1), %reg2
1045 */
1046
1047 if (offset < 2 || (offset + 4) > sec->size)
1048 return FALSE;
1049
1050 val = bfd_get_8 (abfd, contents + offset - 1);
1051 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1052 return FALSE;
1053
1054 type = bfd_get_8 (abfd, contents + offset - 2);
1055 return type == 0x8b || type == 0x2b || type == 0x03;
1056
1057 case R_386_TLS_GOTDESC:
1058 /* Check transition from GDesc access model:
1059 leal x@tlsdesc(%ebx), %eax
1060
1061 Make sure it's a leal adding ebx to a 32-bit offset
1062 into any register, although it's probably almost always
1063 going to be eax. */
1064
1065 if (offset < 2 || (offset + 4) > sec->size)
1066 return FALSE;
1067
1068 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1069 return FALSE;
1070
1071 val = bfd_get_8 (abfd, contents + offset - 1);
1072 return (val & 0xc7) == 0x83;
1073
1074 case R_386_TLS_DESC_CALL:
1075 /* Check transition from GDesc access model:
1076 call *x@tlsdesc(%rax)
1077 */
1078 if (offset + 2 <= sec->size)
1079 {
1080 /* Make sure that it's a call *x@tlsdesc(%rax). */
1081 static i386_opcode16 call = { { 0xff, 0x10 } };
1082 return bfd_get_16 (abfd, contents + offset) == call.i;
1083 }
1084
1085 return FALSE;
1086
1087 default:
1088 abort ();
1089 }
1090 }
1091
1092 /* Return TRUE if the TLS access transition is OK or no transition
1093 will be performed. Update R_TYPE if there is a transition. */
1094
1095 static bfd_boolean
1096 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1097 asection *sec, bfd_byte *contents,
1098 Elf_Internal_Shdr *symtab_hdr,
1099 struct elf_link_hash_entry **sym_hashes,
1100 unsigned int *r_type, int tls_type,
1101 const Elf_Internal_Rela *rel,
1102 const Elf_Internal_Rela *relend,
1103 struct elf_link_hash_entry *h)
1104 {
1105 unsigned int from_type = *r_type;
1106 unsigned int to_type = from_type;
1107 bfd_boolean check = TRUE;
1108
1109 switch (from_type)
1110 {
1111 case R_386_TLS_GD:
1112 case R_386_TLS_GOTDESC:
1113 case R_386_TLS_DESC_CALL:
1114 case R_386_TLS_IE_32:
1115 case R_386_TLS_IE:
1116 case R_386_TLS_GOTIE:
1117 if (!info->shared)
1118 {
1119 if (h == NULL)
1120 to_type = R_386_TLS_LE_32;
1121 else if (from_type != R_386_TLS_IE
1122 && from_type != R_386_TLS_GOTIE)
1123 to_type = R_386_TLS_IE_32;
1124 }
1125
1126 /* When we are called from elf_i386_relocate_section, CONTENTS
1127 isn't NULL and there may be additional transitions based on
1128 TLS_TYPE. */
1129 if (contents != NULL)
1130 {
1131 unsigned int new_to_type = to_type;
1132
1133 if (!info->shared
1134 && h != NULL
1135 && h->dynindx == -1
1136 && (tls_type & GOT_TLS_IE))
1137 new_to_type = R_386_TLS_LE_32;
1138
1139 if (to_type == R_386_TLS_GD
1140 || to_type == R_386_TLS_GOTDESC
1141 || to_type == R_386_TLS_DESC_CALL)
1142 {
1143 if (tls_type == GOT_TLS_IE_POS)
1144 new_to_type = R_386_TLS_GOTIE;
1145 else if (tls_type & GOT_TLS_IE)
1146 new_to_type = R_386_TLS_IE_32;
1147 }
1148
1149 /* We checked the transition before when we were called from
1150 elf_i386_check_relocs. We only want to check the new
1151 transition which hasn't been checked before. */
1152 check = new_to_type != to_type && from_type == to_type;
1153 to_type = new_to_type;
1154 }
1155
1156 break;
1157
1158 case R_386_TLS_LDM:
1159 if (!info->shared)
1160 to_type = R_386_TLS_LE_32;
1161 break;
1162
1163 default:
1164 return TRUE;
1165 }
1166
1167 /* Return TRUE if there is no transition. */
1168 if (from_type == to_type)
1169 return TRUE;
1170
1171 /* Check if the transition can be performed. */
1172 if (check
1173 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1174 symtab_hdr, sym_hashes,
1175 from_type, rel, relend))
1176 {
1177 reloc_howto_type *from, *to;
1178
1179 from = elf_i386_rtype_to_howto (abfd, from_type);
1180 to = elf_i386_rtype_to_howto (abfd, to_type);
1181
1182 (*_bfd_error_handler)
1183 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1184 "in section `%A' failed"),
1185 abfd, sec, from->name, to->name,
1186 h ? h->root.root.string : "a local symbol",
1187 (unsigned long) rel->r_offset);
1188 bfd_set_error (bfd_error_bad_value);
1189 return FALSE;
1190 }
1191
1192 *r_type = to_type;
1193 return TRUE;
1194 }
1195
1196 /* Look through the relocs for a section during the first phase, and
1197 calculate needed space in the global offset table, procedure linkage
1198 table, and dynamic reloc sections. */
1199
1200 static bfd_boolean
1201 elf_i386_check_relocs (bfd *abfd,
1202 struct bfd_link_info *info,
1203 asection *sec,
1204 const Elf_Internal_Rela *relocs)
1205 {
1206 struct elf_i386_link_hash_table *htab;
1207 Elf_Internal_Shdr *symtab_hdr;
1208 struct elf_link_hash_entry **sym_hashes;
1209 const Elf_Internal_Rela *rel;
1210 const Elf_Internal_Rela *rel_end;
1211 asection *sreloc;
1212
1213 if (info->relocatable)
1214 return TRUE;
1215
1216 BFD_ASSERT (is_i386_elf (abfd));
1217
1218 htab = elf_i386_hash_table (info);
1219 symtab_hdr = &elf_symtab_hdr (abfd);
1220 sym_hashes = elf_sym_hashes (abfd);
1221
1222 sreloc = NULL;
1223
1224 rel_end = relocs + sec->reloc_count;
1225 for (rel = relocs; rel < rel_end; rel++)
1226 {
1227 unsigned int r_type;
1228 unsigned long r_symndx;
1229 struct elf_link_hash_entry *h;
1230
1231 r_symndx = ELF32_R_SYM (rel->r_info);
1232 r_type = ELF32_R_TYPE (rel->r_info);
1233
1234 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1235 {
1236 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1237 abfd,
1238 r_symndx);
1239 return FALSE;
1240 }
1241
1242 if (r_symndx < symtab_hdr->sh_info)
1243 h = NULL;
1244 else
1245 {
1246 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1247 while (h->root.type == bfd_link_hash_indirect
1248 || h->root.type == bfd_link_hash_warning)
1249 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1250 }
1251
1252 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1253 symtab_hdr, sym_hashes,
1254 &r_type, GOT_UNKNOWN,
1255 rel, rel_end, h))
1256 return FALSE;
1257
1258 switch (r_type)
1259 {
1260 case R_386_TLS_LDM:
1261 htab->tls_ldm_got.refcount += 1;
1262 goto create_got;
1263
1264 case R_386_PLT32:
1265 /* This symbol requires a procedure linkage table entry. We
1266 actually build the entry in adjust_dynamic_symbol,
1267 because this might be a case of linking PIC code which is
1268 never referenced by a dynamic object, in which case we
1269 don't need to generate a procedure linkage table entry
1270 after all. */
1271
1272 /* If this is a local symbol, we resolve it directly without
1273 creating a procedure linkage table entry. */
1274 if (h == NULL)
1275 continue;
1276
1277 h->needs_plt = 1;
1278 h->plt.refcount += 1;
1279 break;
1280
1281 case R_386_TLS_IE_32:
1282 case R_386_TLS_IE:
1283 case R_386_TLS_GOTIE:
1284 if (info->shared)
1285 info->flags |= DF_STATIC_TLS;
1286 /* Fall through */
1287
1288 case R_386_GOT32:
1289 case R_386_TLS_GD:
1290 case R_386_TLS_GOTDESC:
1291 case R_386_TLS_DESC_CALL:
1292 /* This symbol requires a global offset table entry. */
1293 {
1294 int tls_type, old_tls_type;
1295
1296 switch (r_type)
1297 {
1298 default:
1299 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1300 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1301 case R_386_TLS_GOTDESC:
1302 case R_386_TLS_DESC_CALL:
1303 tls_type = GOT_TLS_GDESC; break;
1304 case R_386_TLS_IE_32:
1305 if (ELF32_R_TYPE (rel->r_info) == r_type)
1306 tls_type = GOT_TLS_IE_NEG;
1307 else
1308 /* If this is a GD->IE transition, we may use either of
1309 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1310 tls_type = GOT_TLS_IE;
1311 break;
1312 case R_386_TLS_IE:
1313 case R_386_TLS_GOTIE:
1314 tls_type = GOT_TLS_IE_POS; break;
1315 }
1316
1317 if (h != NULL)
1318 {
1319 h->got.refcount += 1;
1320 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1321 }
1322 else
1323 {
1324 bfd_signed_vma *local_got_refcounts;
1325
1326 /* This is a global offset table entry for a local symbol. */
1327 local_got_refcounts = elf_local_got_refcounts (abfd);
1328 if (local_got_refcounts == NULL)
1329 {
1330 bfd_size_type size;
1331
1332 size = symtab_hdr->sh_info;
1333 size *= (sizeof (bfd_signed_vma)
1334 + sizeof (bfd_vma) + sizeof(char));
1335 local_got_refcounts = bfd_zalloc (abfd, size);
1336 if (local_got_refcounts == NULL)
1337 return FALSE;
1338 elf_local_got_refcounts (abfd) = local_got_refcounts;
1339 elf_i386_local_tlsdesc_gotent (abfd)
1340 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1341 elf_i386_local_got_tls_type (abfd)
1342 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1343 }
1344 local_got_refcounts[r_symndx] += 1;
1345 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1346 }
1347
1348 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1349 tls_type |= old_tls_type;
1350 /* If a TLS symbol is accessed using IE at least once,
1351 there is no point to use dynamic model for it. */
1352 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1353 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1354 || (tls_type & GOT_TLS_IE) == 0))
1355 {
1356 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1357 tls_type = old_tls_type;
1358 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1359 && GOT_TLS_GD_ANY_P (tls_type))
1360 tls_type |= old_tls_type;
1361 else
1362 {
1363 (*_bfd_error_handler)
1364 (_("%B: `%s' accessed both as normal and "
1365 "thread local symbol"),
1366 abfd,
1367 h ? h->root.root.string : "<local>");
1368 return FALSE;
1369 }
1370 }
1371
1372 if (old_tls_type != tls_type)
1373 {
1374 if (h != NULL)
1375 elf_i386_hash_entry (h)->tls_type = tls_type;
1376 else
1377 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1378 }
1379 }
1380 /* Fall through */
1381
1382 case R_386_GOTOFF:
1383 case R_386_GOTPC:
1384 create_got:
1385 if (htab->sgot == NULL)
1386 {
1387 if (htab->elf.dynobj == NULL)
1388 htab->elf.dynobj = abfd;
1389 if (!create_got_section (htab->elf.dynobj, info))
1390 return FALSE;
1391 }
1392 if (r_type != R_386_TLS_IE)
1393 break;
1394 /* Fall through */
1395
1396 case R_386_TLS_LE_32:
1397 case R_386_TLS_LE:
1398 if (!info->shared)
1399 break;
1400 info->flags |= DF_STATIC_TLS;
1401 /* Fall through */
1402
1403 case R_386_32:
1404 case R_386_PC32:
1405 if (h != NULL && !info->shared)
1406 {
1407 /* If this reloc is in a read-only section, we might
1408 need a copy reloc. We can't check reliably at this
1409 stage whether the section is read-only, as input
1410 sections have not yet been mapped to output sections.
1411 Tentatively set the flag for now, and correct in
1412 adjust_dynamic_symbol. */
1413 h->non_got_ref = 1;
1414
1415 /* We may need a .plt entry if the function this reloc
1416 refers to is in a shared lib. */
1417 h->plt.refcount += 1;
1418 if (r_type != R_386_PC32)
1419 h->pointer_equality_needed = 1;
1420 }
1421
1422 /* If we are creating a shared library, and this is a reloc
1423 against a global symbol, or a non PC relative reloc
1424 against a local symbol, then we need to copy the reloc
1425 into the shared library. However, if we are linking with
1426 -Bsymbolic, we do not need to copy a reloc against a
1427 global symbol which is defined in an object we are
1428 including in the link (i.e., DEF_REGULAR is set). At
1429 this point we have not seen all the input files, so it is
1430 possible that DEF_REGULAR is not set now but will be set
1431 later (it is never cleared). In case of a weak definition,
1432 DEF_REGULAR may be cleared later by a strong definition in
1433 a shared library. We account for that possibility below by
1434 storing information in the relocs_copied field of the hash
1435 table entry. A similar situation occurs when creating
1436 shared libraries and symbol visibility changes render the
1437 symbol local.
1438
1439 If on the other hand, we are creating an executable, we
1440 may need to keep relocations for symbols satisfied by a
1441 dynamic library if we manage to avoid copy relocs for the
1442 symbol. */
1443 if ((info->shared
1444 && (sec->flags & SEC_ALLOC) != 0
1445 && (r_type != R_386_PC32
1446 || (h != NULL
1447 && (! SYMBOLIC_BIND (info, h)
1448 || h->root.type == bfd_link_hash_defweak
1449 || !h->def_regular))))
1450 || (ELIMINATE_COPY_RELOCS
1451 && !info->shared
1452 && (sec->flags & SEC_ALLOC) != 0
1453 && h != NULL
1454 && (h->root.type == bfd_link_hash_defweak
1455 || !h->def_regular)))
1456 {
1457 struct elf_i386_dyn_relocs *p;
1458 struct elf_i386_dyn_relocs **head;
1459
1460 /* We must copy these reloc types into the output file.
1461 Create a reloc section in dynobj and make room for
1462 this reloc. */
1463 if (sreloc == NULL)
1464 {
1465 const char *name;
1466 bfd *dynobj;
1467 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1468 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1469
1470 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1471 if (name == NULL)
1472 return FALSE;
1473
1474 if (! CONST_STRNEQ (name, ".rel")
1475 || strcmp (bfd_get_section_name (abfd, sec),
1476 name + 4) != 0)
1477 {
1478 (*_bfd_error_handler)
1479 (_("%B: bad relocation section name `%s\'"),
1480 abfd, name);
1481 }
1482
1483 if (htab->elf.dynobj == NULL)
1484 htab->elf.dynobj = abfd;
1485
1486 dynobj = htab->elf.dynobj;
1487 sreloc = bfd_get_section_by_name (dynobj, name);
1488 if (sreloc == NULL)
1489 {
1490 flagword flags;
1491
1492 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1493 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1494 if ((sec->flags & SEC_ALLOC) != 0)
1495 flags |= SEC_ALLOC | SEC_LOAD;
1496 sreloc = bfd_make_section_with_flags (dynobj,
1497 name,
1498 flags);
1499 if (sreloc == NULL
1500 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1501 return FALSE;
1502 }
1503 elf_section_data (sec)->sreloc = sreloc;
1504 }
1505
1506 /* If this is a global symbol, we count the number of
1507 relocations we need for this symbol. */
1508 if (h != NULL)
1509 {
1510 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1511 }
1512 else
1513 {
1514 void **vpp;
1515 /* Track dynamic relocs needed for local syms too.
1516 We really need local syms available to do this
1517 easily. Oh well. */
1518
1519 asection *s;
1520 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1521 sec, r_symndx);
1522 if (s == NULL)
1523 return FALSE;
1524
1525 vpp = &elf_section_data (s)->local_dynrel;
1526 head = (struct elf_i386_dyn_relocs **)vpp;
1527 }
1528
1529 p = *head;
1530 if (p == NULL || p->sec != sec)
1531 {
1532 bfd_size_type amt = sizeof *p;
1533 p = bfd_alloc (htab->elf.dynobj, amt);
1534 if (p == NULL)
1535 return FALSE;
1536 p->next = *head;
1537 *head = p;
1538 p->sec = sec;
1539 p->count = 0;
1540 p->pc_count = 0;
1541 }
1542
1543 p->count += 1;
1544 if (r_type == R_386_PC32)
1545 p->pc_count += 1;
1546 }
1547 break;
1548
1549 /* This relocation describes the C++ object vtable hierarchy.
1550 Reconstruct it for later use during GC. */
1551 case R_386_GNU_VTINHERIT:
1552 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1553 return FALSE;
1554 break;
1555
1556 /* This relocation describes which C++ vtable entries are actually
1557 used. Record for later use during GC. */
1558 case R_386_GNU_VTENTRY:
1559 BFD_ASSERT (h != NULL);
1560 if (h != NULL
1561 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1562 return FALSE;
1563 break;
1564
1565 default:
1566 break;
1567 }
1568 }
1569
1570 return TRUE;
1571 }
1572
1573 /* Return the section that should be marked against GC for a given
1574 relocation. */
1575
1576 static asection *
1577 elf_i386_gc_mark_hook (asection *sec,
1578 struct bfd_link_info *info,
1579 Elf_Internal_Rela *rel,
1580 struct elf_link_hash_entry *h,
1581 Elf_Internal_Sym *sym)
1582 {
1583 if (h != NULL)
1584 switch (ELF32_R_TYPE (rel->r_info))
1585 {
1586 case R_386_GNU_VTINHERIT:
1587 case R_386_GNU_VTENTRY:
1588 return NULL;
1589 }
1590
1591 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1592 }
1593
1594 /* Update the got entry reference counts for the section being removed. */
1595
1596 static bfd_boolean
1597 elf_i386_gc_sweep_hook (bfd *abfd,
1598 struct bfd_link_info *info,
1599 asection *sec,
1600 const Elf_Internal_Rela *relocs)
1601 {
1602 Elf_Internal_Shdr *symtab_hdr;
1603 struct elf_link_hash_entry **sym_hashes;
1604 bfd_signed_vma *local_got_refcounts;
1605 const Elf_Internal_Rela *rel, *relend;
1606
1607 if (info->relocatable)
1608 return TRUE;
1609
1610 elf_section_data (sec)->local_dynrel = NULL;
1611
1612 symtab_hdr = &elf_symtab_hdr (abfd);
1613 sym_hashes = elf_sym_hashes (abfd);
1614 local_got_refcounts = elf_local_got_refcounts (abfd);
1615
1616 relend = relocs + sec->reloc_count;
1617 for (rel = relocs; rel < relend; rel++)
1618 {
1619 unsigned long r_symndx;
1620 unsigned int r_type;
1621 struct elf_link_hash_entry *h = NULL;
1622
1623 r_symndx = ELF32_R_SYM (rel->r_info);
1624 if (r_symndx >= symtab_hdr->sh_info)
1625 {
1626 struct elf_i386_link_hash_entry *eh;
1627 struct elf_i386_dyn_relocs **pp;
1628 struct elf_i386_dyn_relocs *p;
1629
1630 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1631 while (h->root.type == bfd_link_hash_indirect
1632 || h->root.type == bfd_link_hash_warning)
1633 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1634 eh = (struct elf_i386_link_hash_entry *) h;
1635
1636 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1637 if (p->sec == sec)
1638 {
1639 /* Everything must go for SEC. */
1640 *pp = p->next;
1641 break;
1642 }
1643 }
1644
1645 r_type = ELF32_R_TYPE (rel->r_info);
1646 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1647 symtab_hdr, sym_hashes,
1648 &r_type, GOT_UNKNOWN,
1649 rel, relend, h))
1650 return FALSE;
1651
1652 switch (r_type)
1653 {
1654 case R_386_TLS_LDM:
1655 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1656 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1657 break;
1658
1659 case R_386_TLS_GD:
1660 case R_386_TLS_GOTDESC:
1661 case R_386_TLS_DESC_CALL:
1662 case R_386_TLS_IE_32:
1663 case R_386_TLS_IE:
1664 case R_386_TLS_GOTIE:
1665 case R_386_GOT32:
1666 if (h != NULL)
1667 {
1668 if (h->got.refcount > 0)
1669 h->got.refcount -= 1;
1670 }
1671 else if (local_got_refcounts != NULL)
1672 {
1673 if (local_got_refcounts[r_symndx] > 0)
1674 local_got_refcounts[r_symndx] -= 1;
1675 }
1676 break;
1677
1678 case R_386_32:
1679 case R_386_PC32:
1680 if (info->shared)
1681 break;
1682 /* Fall through */
1683
1684 case R_386_PLT32:
1685 if (h != NULL)
1686 {
1687 if (h->plt.refcount > 0)
1688 h->plt.refcount -= 1;
1689 }
1690 break;
1691
1692 default:
1693 break;
1694 }
1695 }
1696
1697 return TRUE;
1698 }
1699
1700 /* Adjust a symbol defined by a dynamic object and referenced by a
1701 regular object. The current definition is in some section of the
1702 dynamic object, but we're not including those sections. We have to
1703 change the definition to something the rest of the link can
1704 understand. */
1705
1706 static bfd_boolean
1707 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1708 struct elf_link_hash_entry *h)
1709 {
1710 struct elf_i386_link_hash_table *htab;
1711 asection *s;
1712
1713 /* If this is a function, put it in the procedure linkage table. We
1714 will fill in the contents of the procedure linkage table later,
1715 when we know the address of the .got section. */
1716 if (h->type == STT_FUNC
1717 || h->needs_plt)
1718 {
1719 if (h->plt.refcount <= 0
1720 || SYMBOL_CALLS_LOCAL (info, h)
1721 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1722 && h->root.type == bfd_link_hash_undefweak))
1723 {
1724 /* This case can occur if we saw a PLT32 reloc in an input
1725 file, but the symbol was never referred to by a dynamic
1726 object, or if all references were garbage collected. In
1727 such a case, we don't actually need to build a procedure
1728 linkage table, and we can just do a PC32 reloc instead. */
1729 h->plt.offset = (bfd_vma) -1;
1730 h->needs_plt = 0;
1731 }
1732
1733 return TRUE;
1734 }
1735 else
1736 /* It's possible that we incorrectly decided a .plt reloc was
1737 needed for an R_386_PC32 reloc to a non-function sym in
1738 check_relocs. We can't decide accurately between function and
1739 non-function syms in check-relocs; Objects loaded later in
1740 the link may change h->type. So fix it now. */
1741 h->plt.offset = (bfd_vma) -1;
1742
1743 /* If this is a weak symbol, and there is a real definition, the
1744 processor independent code will have arranged for us to see the
1745 real definition first, and we can just use the same value. */
1746 if (h->u.weakdef != NULL)
1747 {
1748 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1749 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1750 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1751 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1752 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1753 h->non_got_ref = h->u.weakdef->non_got_ref;
1754 return TRUE;
1755 }
1756
1757 /* This is a reference to a symbol defined by a dynamic object which
1758 is not a function. */
1759
1760 /* If we are creating a shared library, we must presume that the
1761 only references to the symbol are via the global offset table.
1762 For such cases we need not do anything here; the relocations will
1763 be handled correctly by relocate_section. */
1764 if (info->shared)
1765 return TRUE;
1766
1767 /* If there are no references to this symbol that do not use the
1768 GOT, we don't need to generate a copy reloc. */
1769 if (!h->non_got_ref)
1770 return TRUE;
1771
1772 /* If -z nocopyreloc was given, we won't generate them either. */
1773 if (info->nocopyreloc)
1774 {
1775 h->non_got_ref = 0;
1776 return TRUE;
1777 }
1778
1779 htab = elf_i386_hash_table (info);
1780
1781 /* If there aren't any dynamic relocs in read-only sections, then
1782 we can keep the dynamic relocs and avoid the copy reloc. This
1783 doesn't work on VxWorks, where we can not have dynamic relocations
1784 (other than copy and jump slot relocations) in an executable. */
1785 if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1786 {
1787 struct elf_i386_link_hash_entry * eh;
1788 struct elf_i386_dyn_relocs *p;
1789
1790 eh = (struct elf_i386_link_hash_entry *) h;
1791 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1792 {
1793 s = p->sec->output_section;
1794 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1795 break;
1796 }
1797
1798 if (p == NULL)
1799 {
1800 h->non_got_ref = 0;
1801 return TRUE;
1802 }
1803 }
1804
1805 if (h->size == 0)
1806 {
1807 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1808 h->root.root.string);
1809 return TRUE;
1810 }
1811
1812 /* We must allocate the symbol in our .dynbss section, which will
1813 become part of the .bss section of the executable. There will be
1814 an entry for this symbol in the .dynsym section. The dynamic
1815 object will contain position independent code, so all references
1816 from the dynamic object to this symbol will go through the global
1817 offset table. The dynamic linker will use the .dynsym entry to
1818 determine the address it must put in the global offset table, so
1819 both the dynamic object and the regular object will refer to the
1820 same memory location for the variable. */
1821
1822 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1823 copy the initial value out of the dynamic object and into the
1824 runtime process image. */
1825 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1826 {
1827 htab->srelbss->size += sizeof (Elf32_External_Rel);
1828 h->needs_copy = 1;
1829 }
1830
1831 s = htab->sdynbss;
1832
1833 return _bfd_elf_adjust_dynamic_copy (h, s);
1834 }
1835
1836 /* Allocate space in .plt, .got and associated reloc sections for
1837 dynamic relocs. */
1838
1839 static bfd_boolean
1840 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1841 {
1842 struct bfd_link_info *info;
1843 struct elf_i386_link_hash_table *htab;
1844 struct elf_i386_link_hash_entry *eh;
1845 struct elf_i386_dyn_relocs *p;
1846
1847 if (h->root.type == bfd_link_hash_indirect)
1848 return TRUE;
1849
1850 if (h->root.type == bfd_link_hash_warning)
1851 /* When warning symbols are created, they **replace** the "real"
1852 entry in the hash table, thus we never get to see the real
1853 symbol in a hash traversal. So look at it now. */
1854 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1855
1856 info = (struct bfd_link_info *) inf;
1857 htab = elf_i386_hash_table (info);
1858
1859 if (htab->elf.dynamic_sections_created
1860 && h->plt.refcount > 0)
1861 {
1862 /* Make sure this symbol is output as a dynamic symbol.
1863 Undefined weak syms won't yet be marked as dynamic. */
1864 if (h->dynindx == -1
1865 && !h->forced_local)
1866 {
1867 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1868 return FALSE;
1869 }
1870
1871 if (info->shared
1872 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1873 {
1874 asection *s = htab->splt;
1875
1876 /* If this is the first .plt entry, make room for the special
1877 first entry. */
1878 if (s->size == 0)
1879 s->size += PLT_ENTRY_SIZE;
1880
1881 h->plt.offset = s->size;
1882
1883 /* If this symbol is not defined in a regular file, and we are
1884 not generating a shared library, then set the symbol to this
1885 location in the .plt. This is required to make function
1886 pointers compare as equal between the normal executable and
1887 the shared library. */
1888 if (! info->shared
1889 && !h->def_regular)
1890 {
1891 h->root.u.def.section = s;
1892 h->root.u.def.value = h->plt.offset;
1893 }
1894
1895 /* Make room for this entry. */
1896 s->size += PLT_ENTRY_SIZE;
1897
1898 /* We also need to make an entry in the .got.plt section, which
1899 will be placed in the .got section by the linker script. */
1900 htab->sgotplt->size += 4;
1901
1902 /* We also need to make an entry in the .rel.plt section. */
1903 htab->srelplt->size += sizeof (Elf32_External_Rel);
1904 htab->next_tls_desc_index++;
1905
1906 if (htab->is_vxworks && !info->shared)
1907 {
1908 /* VxWorks has a second set of relocations for each PLT entry
1909 in executables. They go in a separate relocation section,
1910 which is processed by the kernel loader. */
1911
1912 /* There are two relocations for the initial PLT entry: an
1913 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1914 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1915
1916 if (h->plt.offset == PLT_ENTRY_SIZE)
1917 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1918
1919 /* There are two extra relocations for each subsequent PLT entry:
1920 an R_386_32 relocation for the GOT entry, and an R_386_32
1921 relocation for the PLT entry. */
1922
1923 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1924 }
1925 }
1926 else
1927 {
1928 h->plt.offset = (bfd_vma) -1;
1929 h->needs_plt = 0;
1930 }
1931 }
1932 else
1933 {
1934 h->plt.offset = (bfd_vma) -1;
1935 h->needs_plt = 0;
1936 }
1937
1938 eh = (struct elf_i386_link_hash_entry *) h;
1939 eh->tlsdesc_got = (bfd_vma) -1;
1940
1941 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1942 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1943 if (h->got.refcount > 0
1944 && !info->shared
1945 && h->dynindx == -1
1946 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1947 h->got.offset = (bfd_vma) -1;
1948 else if (h->got.refcount > 0)
1949 {
1950 asection *s;
1951 bfd_boolean dyn;
1952 int tls_type = elf_i386_hash_entry(h)->tls_type;
1953
1954 /* Make sure this symbol is output as a dynamic symbol.
1955 Undefined weak syms won't yet be marked as dynamic. */
1956 if (h->dynindx == -1
1957 && !h->forced_local)
1958 {
1959 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1960 return FALSE;
1961 }
1962
1963 s = htab->sgot;
1964 if (GOT_TLS_GDESC_P (tls_type))
1965 {
1966 eh->tlsdesc_got = htab->sgotplt->size
1967 - elf_i386_compute_jump_table_size (htab);
1968 htab->sgotplt->size += 8;
1969 h->got.offset = (bfd_vma) -2;
1970 }
1971 if (! GOT_TLS_GDESC_P (tls_type)
1972 || GOT_TLS_GD_P (tls_type))
1973 {
1974 h->got.offset = s->size;
1975 s->size += 4;
1976 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1977 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1978 s->size += 4;
1979 }
1980 dyn = htab->elf.dynamic_sections_created;
1981 /* R_386_TLS_IE_32 needs one dynamic relocation,
1982 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1983 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1984 need two), R_386_TLS_GD needs one if local symbol and two if
1985 global. */
1986 if (tls_type == GOT_TLS_IE_BOTH)
1987 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1988 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1989 || (tls_type & GOT_TLS_IE))
1990 htab->srelgot->size += sizeof (Elf32_External_Rel);
1991 else if (GOT_TLS_GD_P (tls_type))
1992 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1993 else if (! GOT_TLS_GDESC_P (tls_type)
1994 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1995 || h->root.type != bfd_link_hash_undefweak)
1996 && (info->shared
1997 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1998 htab->srelgot->size += sizeof (Elf32_External_Rel);
1999 if (GOT_TLS_GDESC_P (tls_type))
2000 htab->srelplt->size += sizeof (Elf32_External_Rel);
2001 }
2002 else
2003 h->got.offset = (bfd_vma) -1;
2004
2005 if (eh->dyn_relocs == NULL)
2006 return TRUE;
2007
2008 /* In the shared -Bsymbolic case, discard space allocated for
2009 dynamic pc-relative relocs against symbols which turn out to be
2010 defined in regular objects. For the normal shared case, discard
2011 space for pc-relative relocs that have become local due to symbol
2012 visibility changes. */
2013
2014 if (info->shared)
2015 {
2016 /* The only reloc that uses pc_count is R_386_PC32, which will
2017 appear on a call or on something like ".long foo - .". We
2018 want calls to protected symbols to resolve directly to the
2019 function rather than going via the plt. If people want
2020 function pointer comparisons to work as expected then they
2021 should avoid writing assembly like ".long foo - .". */
2022 if (SYMBOL_CALLS_LOCAL (info, h))
2023 {
2024 struct elf_i386_dyn_relocs **pp;
2025
2026 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2027 {
2028 p->count -= p->pc_count;
2029 p->pc_count = 0;
2030 if (p->count == 0)
2031 *pp = p->next;
2032 else
2033 pp = &p->next;
2034 }
2035 }
2036
2037 if (htab->is_vxworks)
2038 {
2039 struct elf_i386_dyn_relocs **pp;
2040 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2041 {
2042 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2043 *pp = p->next;
2044 else
2045 pp = &p->next;
2046 }
2047 }
2048
2049 /* Also discard relocs on undefined weak syms with non-default
2050 visibility. */
2051 if (eh->dyn_relocs != NULL
2052 && h->root.type == bfd_link_hash_undefweak)
2053 {
2054 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2055 eh->dyn_relocs = NULL;
2056
2057 /* Make sure undefined weak symbols are output as a dynamic
2058 symbol in PIEs. */
2059 else if (h->dynindx == -1
2060 && !h->forced_local)
2061 {
2062 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2063 return FALSE;
2064 }
2065 }
2066 }
2067 else if (ELIMINATE_COPY_RELOCS)
2068 {
2069 /* For the non-shared case, discard space for relocs against
2070 symbols which turn out to need copy relocs or are not
2071 dynamic. */
2072
2073 if (!h->non_got_ref
2074 && ((h->def_dynamic
2075 && !h->def_regular)
2076 || (htab->elf.dynamic_sections_created
2077 && (h->root.type == bfd_link_hash_undefweak
2078 || h->root.type == bfd_link_hash_undefined))))
2079 {
2080 /* Make sure this symbol is output as a dynamic symbol.
2081 Undefined weak syms won't yet be marked as dynamic. */
2082 if (h->dynindx == -1
2083 && !h->forced_local)
2084 {
2085 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2086 return FALSE;
2087 }
2088
2089 /* If that succeeded, we know we'll be keeping all the
2090 relocs. */
2091 if (h->dynindx != -1)
2092 goto keep;
2093 }
2094
2095 eh->dyn_relocs = NULL;
2096
2097 keep: ;
2098 }
2099
2100 /* Finally, allocate space. */
2101 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2102 {
2103 asection *sreloc = elf_section_data (p->sec)->sreloc;
2104 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2105 }
2106
2107 return TRUE;
2108 }
2109
2110 /* Find any dynamic relocs that apply to read-only sections. */
2111
2112 static bfd_boolean
2113 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2114 {
2115 struct elf_i386_link_hash_entry *eh;
2116 struct elf_i386_dyn_relocs *p;
2117
2118 if (h->root.type == bfd_link_hash_warning)
2119 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2120
2121 eh = (struct elf_i386_link_hash_entry *) h;
2122 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2123 {
2124 asection *s = p->sec->output_section;
2125
2126 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2127 {
2128 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2129
2130 info->flags |= DF_TEXTREL;
2131
2132 /* Not an error, just cut short the traversal. */
2133 return FALSE;
2134 }
2135 }
2136 return TRUE;
2137 }
2138
2139 /* Set the sizes of the dynamic sections. */
2140
2141 static bfd_boolean
2142 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2143 struct bfd_link_info *info)
2144 {
2145 struct elf_i386_link_hash_table *htab;
2146 bfd *dynobj;
2147 asection *s;
2148 bfd_boolean relocs;
2149 bfd *ibfd;
2150
2151 htab = elf_i386_hash_table (info);
2152 dynobj = htab->elf.dynobj;
2153 if (dynobj == NULL)
2154 abort ();
2155
2156 if (htab->elf.dynamic_sections_created)
2157 {
2158 /* Set the contents of the .interp section to the interpreter. */
2159 if (info->executable)
2160 {
2161 s = bfd_get_section_by_name (dynobj, ".interp");
2162 if (s == NULL)
2163 abort ();
2164 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2165 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2166 }
2167 }
2168
2169 /* Set up .got offsets for local syms, and space for local dynamic
2170 relocs. */
2171 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2172 {
2173 bfd_signed_vma *local_got;
2174 bfd_signed_vma *end_local_got;
2175 char *local_tls_type;
2176 bfd_vma *local_tlsdesc_gotent;
2177 bfd_size_type locsymcount;
2178 Elf_Internal_Shdr *symtab_hdr;
2179 asection *srel;
2180
2181 if (! is_i386_elf (ibfd))
2182 continue;
2183
2184 for (s = ibfd->sections; s != NULL; s = s->next)
2185 {
2186 struct elf_i386_dyn_relocs *p;
2187
2188 for (p = ((struct elf_i386_dyn_relocs *)
2189 elf_section_data (s)->local_dynrel);
2190 p != NULL;
2191 p = p->next)
2192 {
2193 if (!bfd_is_abs_section (p->sec)
2194 && bfd_is_abs_section (p->sec->output_section))
2195 {
2196 /* Input section has been discarded, either because
2197 it is a copy of a linkonce section or due to
2198 linker script /DISCARD/, so we'll be discarding
2199 the relocs too. */
2200 }
2201 else if (htab->is_vxworks
2202 && strcmp (p->sec->output_section->name,
2203 ".tls_vars") == 0)
2204 {
2205 /* Relocations in vxworks .tls_vars sections are
2206 handled specially by the loader. */
2207 }
2208 else if (p->count != 0)
2209 {
2210 srel = elf_section_data (p->sec)->sreloc;
2211 srel->size += p->count * sizeof (Elf32_External_Rel);
2212 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2213 info->flags |= DF_TEXTREL;
2214 }
2215 }
2216 }
2217
2218 local_got = elf_local_got_refcounts (ibfd);
2219 if (!local_got)
2220 continue;
2221
2222 symtab_hdr = &elf_symtab_hdr (ibfd);
2223 locsymcount = symtab_hdr->sh_info;
2224 end_local_got = local_got + locsymcount;
2225 local_tls_type = elf_i386_local_got_tls_type (ibfd);
2226 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2227 s = htab->sgot;
2228 srel = htab->srelgot;
2229 for (; local_got < end_local_got;
2230 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2231 {
2232 *local_tlsdesc_gotent = (bfd_vma) -1;
2233 if (*local_got > 0)
2234 {
2235 if (GOT_TLS_GDESC_P (*local_tls_type))
2236 {
2237 *local_tlsdesc_gotent = htab->sgotplt->size
2238 - elf_i386_compute_jump_table_size (htab);
2239 htab->sgotplt->size += 8;
2240 *local_got = (bfd_vma) -2;
2241 }
2242 if (! GOT_TLS_GDESC_P (*local_tls_type)
2243 || GOT_TLS_GD_P (*local_tls_type))
2244 {
2245 *local_got = s->size;
2246 s->size += 4;
2247 if (GOT_TLS_GD_P (*local_tls_type)
2248 || *local_tls_type == GOT_TLS_IE_BOTH)
2249 s->size += 4;
2250 }
2251 if (info->shared
2252 || GOT_TLS_GD_ANY_P (*local_tls_type)
2253 || (*local_tls_type & GOT_TLS_IE))
2254 {
2255 if (*local_tls_type == GOT_TLS_IE_BOTH)
2256 srel->size += 2 * sizeof (Elf32_External_Rel);
2257 else if (GOT_TLS_GD_P (*local_tls_type)
2258 || ! GOT_TLS_GDESC_P (*local_tls_type))
2259 srel->size += sizeof (Elf32_External_Rel);
2260 if (GOT_TLS_GDESC_P (*local_tls_type))
2261 htab->srelplt->size += sizeof (Elf32_External_Rel);
2262 }
2263 }
2264 else
2265 *local_got = (bfd_vma) -1;
2266 }
2267 }
2268
2269 if (htab->tls_ldm_got.refcount > 0)
2270 {
2271 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2272 relocs. */
2273 htab->tls_ldm_got.offset = htab->sgot->size;
2274 htab->sgot->size += 8;
2275 htab->srelgot->size += sizeof (Elf32_External_Rel);
2276 }
2277 else
2278 htab->tls_ldm_got.offset = -1;
2279
2280 /* Allocate global sym .plt and .got entries, and space for global
2281 sym dynamic relocs. */
2282 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2283
2284 /* For every jump slot reserved in the sgotplt, reloc_count is
2285 incremented. However, when we reserve space for TLS descriptors,
2286 it's not incremented, so in order to compute the space reserved
2287 for them, it suffices to multiply the reloc count by the jump
2288 slot size. */
2289 if (htab->srelplt)
2290 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2291
2292 /* We now have determined the sizes of the various dynamic sections.
2293 Allocate memory for them. */
2294 relocs = FALSE;
2295 for (s = dynobj->sections; s != NULL; s = s->next)
2296 {
2297 bfd_boolean strip_section = TRUE;
2298
2299 if ((s->flags & SEC_LINKER_CREATED) == 0)
2300 continue;
2301
2302 if (s == htab->splt
2303 || s == htab->sgot
2304 || s == htab->sgotplt
2305 || s == htab->sdynbss)
2306 {
2307 /* Strip this section if we don't need it; see the
2308 comment below. */
2309 /* We'd like to strip these sections if they aren't needed, but if
2310 we've exported dynamic symbols from them we must leave them.
2311 It's too late to tell BFD to get rid of the symbols. */
2312
2313 if (htab->elf.hplt != NULL)
2314 strip_section = FALSE;
2315 }
2316 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2317 {
2318 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
2319 relocs = TRUE;
2320
2321 /* We use the reloc_count field as a counter if we need
2322 to copy relocs into the output file. */
2323 s->reloc_count = 0;
2324 }
2325 else
2326 {
2327 /* It's not one of our sections, so don't allocate space. */
2328 continue;
2329 }
2330
2331 if (s->size == 0)
2332 {
2333 /* If we don't need this section, strip it from the
2334 output file. This is mostly to handle .rel.bss and
2335 .rel.plt. We must create both sections in
2336 create_dynamic_sections, because they must be created
2337 before the linker maps input sections to output
2338 sections. The linker does that before
2339 adjust_dynamic_symbol is called, and it is that
2340 function which decides whether anything needs to go
2341 into these sections. */
2342 if (strip_section)
2343 s->flags |= SEC_EXCLUDE;
2344 continue;
2345 }
2346
2347 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2348 continue;
2349
2350 /* Allocate memory for the section contents. We use bfd_zalloc
2351 here in case unused entries are not reclaimed before the
2352 section's contents are written out. This should not happen,
2353 but this way if it does, we get a R_386_NONE reloc instead
2354 of garbage. */
2355 s->contents = bfd_zalloc (dynobj, s->size);
2356 if (s->contents == NULL)
2357 return FALSE;
2358 }
2359
2360 if (htab->elf.dynamic_sections_created)
2361 {
2362 /* Add some entries to the .dynamic section. We fill in the
2363 values later, in elf_i386_finish_dynamic_sections, but we
2364 must add the entries now so that we get the correct size for
2365 the .dynamic section. The DT_DEBUG entry is filled in by the
2366 dynamic linker and used by the debugger. */
2367 #define add_dynamic_entry(TAG, VAL) \
2368 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2369
2370 if (info->executable)
2371 {
2372 if (!add_dynamic_entry (DT_DEBUG, 0))
2373 return FALSE;
2374 }
2375
2376 if (htab->splt->size != 0)
2377 {
2378 if (!add_dynamic_entry (DT_PLTGOT, 0)
2379 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2380 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2381 || !add_dynamic_entry (DT_JMPREL, 0))
2382 return FALSE;
2383 }
2384
2385 if (relocs)
2386 {
2387 if (!add_dynamic_entry (DT_REL, 0)
2388 || !add_dynamic_entry (DT_RELSZ, 0)
2389 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2390 return FALSE;
2391
2392 /* If any dynamic relocs apply to a read-only section,
2393 then we need a DT_TEXTREL entry. */
2394 if ((info->flags & DF_TEXTREL) == 0)
2395 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2396 (PTR) info);
2397
2398 if ((info->flags & DF_TEXTREL) != 0)
2399 {
2400 if (!add_dynamic_entry (DT_TEXTREL, 0))
2401 return FALSE;
2402 }
2403 }
2404 if (htab->is_vxworks
2405 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2406 return FALSE;
2407 }
2408 #undef add_dynamic_entry
2409
2410 return TRUE;
2411 }
2412
2413 static bfd_boolean
2414 elf_i386_always_size_sections (bfd *output_bfd,
2415 struct bfd_link_info *info)
2416 {
2417 asection *tls_sec = elf_hash_table (info)->tls_sec;
2418
2419 if (tls_sec)
2420 {
2421 struct elf_link_hash_entry *tlsbase;
2422
2423 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2424 "_TLS_MODULE_BASE_",
2425 FALSE, FALSE, FALSE);
2426
2427 if (tlsbase && tlsbase->type == STT_TLS)
2428 {
2429 struct bfd_link_hash_entry *bh = NULL;
2430 const struct elf_backend_data *bed
2431 = get_elf_backend_data (output_bfd);
2432
2433 if (!(_bfd_generic_link_add_one_symbol
2434 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2435 tls_sec, 0, NULL, FALSE,
2436 bed->collect, &bh)))
2437 return FALSE;
2438
2439 elf_i386_hash_table (info)->tls_module_base = bh;
2440
2441 tlsbase = (struct elf_link_hash_entry *)bh;
2442 tlsbase->def_regular = 1;
2443 tlsbase->other = STV_HIDDEN;
2444 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2445 }
2446 }
2447
2448 return TRUE;
2449 }
2450
2451 /* Set the correct type for an x86 ELF section. We do this by the
2452 section name, which is a hack, but ought to work. */
2453
2454 static bfd_boolean
2455 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2456 Elf_Internal_Shdr *hdr,
2457 asection *sec)
2458 {
2459 register const char *name;
2460
2461 name = bfd_get_section_name (abfd, sec);
2462
2463 /* This is an ugly, but unfortunately necessary hack that is
2464 needed when producing EFI binaries on x86. It tells
2465 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2466 containing ELF relocation info. We need this hack in order to
2467 be able to generate ELF binaries that can be translated into
2468 EFI applications (which are essentially COFF objects). Those
2469 files contain a COFF ".reloc" section inside an ELFNN object,
2470 which would normally cause BFD to segfault because it would
2471 attempt to interpret this section as containing relocation
2472 entries for section "oc". With this hack enabled, ".reloc"
2473 will be treated as a normal data section, which will avoid the
2474 segfault. However, you won't be able to create an ELFNN binary
2475 with a section named "oc" that needs relocations, but that's
2476 the kind of ugly side-effects you get when detecting section
2477 types based on their names... In practice, this limitation is
2478 unlikely to bite. */
2479 if (strcmp (name, ".reloc") == 0)
2480 hdr->sh_type = SHT_PROGBITS;
2481
2482 return TRUE;
2483 }
2484
2485 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2486 executables. Rather than setting it to the beginning of the TLS
2487 section, we have to set it to the end. This function may be called
2488 multiple times, it is idempotent. */
2489
2490 static void
2491 set_tls_module_base (struct bfd_link_info *info)
2492 {
2493 struct bfd_link_hash_entry *base;
2494
2495 if (!info->executable)
2496 return;
2497
2498 base = elf_i386_hash_table (info)->tls_module_base;
2499
2500 if (!base)
2501 return;
2502
2503 base->u.def.value = elf_hash_table (info)->tls_size;
2504 }
2505
2506 /* Return the base VMA address which should be subtracted from real addresses
2507 when resolving @dtpoff relocation.
2508 This is PT_TLS segment p_vaddr. */
2509
2510 static bfd_vma
2511 dtpoff_base (struct bfd_link_info *info)
2512 {
2513 /* If tls_sec is NULL, we should have signalled an error already. */
2514 if (elf_hash_table (info)->tls_sec == NULL)
2515 return 0;
2516 return elf_hash_table (info)->tls_sec->vma;
2517 }
2518
2519 /* Return the relocation value for @tpoff relocation
2520 if STT_TLS virtual address is ADDRESS. */
2521
2522 static bfd_vma
2523 tpoff (struct bfd_link_info *info, bfd_vma address)
2524 {
2525 struct elf_link_hash_table *htab = elf_hash_table (info);
2526
2527 /* If tls_sec is NULL, we should have signalled an error already. */
2528 if (htab->tls_sec == NULL)
2529 return 0;
2530 return htab->tls_size + htab->tls_sec->vma - address;
2531 }
2532
2533 /* Relocate an i386 ELF section. */
2534
2535 static bfd_boolean
2536 elf_i386_relocate_section (bfd *output_bfd,
2537 struct bfd_link_info *info,
2538 bfd *input_bfd,
2539 asection *input_section,
2540 bfd_byte *contents,
2541 Elf_Internal_Rela *relocs,
2542 Elf_Internal_Sym *local_syms,
2543 asection **local_sections)
2544 {
2545 struct elf_i386_link_hash_table *htab;
2546 Elf_Internal_Shdr *symtab_hdr;
2547 struct elf_link_hash_entry **sym_hashes;
2548 bfd_vma *local_got_offsets;
2549 bfd_vma *local_tlsdesc_gotents;
2550 Elf_Internal_Rela *rel;
2551 Elf_Internal_Rela *relend;
2552 bfd_boolean is_vxworks_tls;
2553
2554 BFD_ASSERT (is_i386_elf (input_bfd));
2555
2556 htab = elf_i386_hash_table (info);
2557 symtab_hdr = &elf_symtab_hdr (input_bfd);
2558 sym_hashes = elf_sym_hashes (input_bfd);
2559 local_got_offsets = elf_local_got_offsets (input_bfd);
2560 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
2561 /* We have to handle relocations in vxworks .tls_vars sections
2562 specially, because the dynamic loader is 'weird'. */
2563 is_vxworks_tls = (htab->is_vxworks && info->shared
2564 && !strcmp (input_section->output_section->name,
2565 ".tls_vars"));
2566
2567 set_tls_module_base (info);
2568
2569 rel = relocs;
2570 relend = relocs + input_section->reloc_count;
2571 for (; rel < relend; rel++)
2572 {
2573 unsigned int r_type;
2574 reloc_howto_type *howto;
2575 unsigned long r_symndx;
2576 struct elf_link_hash_entry *h;
2577 Elf_Internal_Sym *sym;
2578 asection *sec;
2579 bfd_vma off, offplt;
2580 bfd_vma relocation;
2581 bfd_boolean unresolved_reloc;
2582 bfd_reloc_status_type r;
2583 unsigned int indx;
2584 int tls_type;
2585
2586 r_type = ELF32_R_TYPE (rel->r_info);
2587 if (r_type == R_386_GNU_VTINHERIT
2588 || r_type == R_386_GNU_VTENTRY)
2589 continue;
2590
2591 if ((indx = r_type) >= R_386_standard
2592 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2593 >= R_386_ext - R_386_standard)
2594 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2595 >= R_386_tls - R_386_ext))
2596 {
2597 (*_bfd_error_handler)
2598 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2599 input_bfd, input_section, r_type);
2600 bfd_set_error (bfd_error_bad_value);
2601 return FALSE;
2602 }
2603 howto = elf_howto_table + indx;
2604
2605 r_symndx = ELF32_R_SYM (rel->r_info);
2606 h = NULL;
2607 sym = NULL;
2608 sec = NULL;
2609 unresolved_reloc = FALSE;
2610 if (r_symndx < symtab_hdr->sh_info)
2611 {
2612 sym = local_syms + r_symndx;
2613 sec = local_sections[r_symndx];
2614 relocation = (sec->output_section->vma
2615 + sec->output_offset
2616 + sym->st_value);
2617
2618 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2619 && ((sec->flags & SEC_MERGE) != 0
2620 || (info->relocatable
2621 && sec->output_offset != 0)))
2622 {
2623 bfd_vma addend;
2624 bfd_byte *where = contents + rel->r_offset;
2625
2626 switch (howto->size)
2627 {
2628 case 0:
2629 addend = bfd_get_8 (input_bfd, where);
2630 if (howto->pc_relative)
2631 {
2632 addend = (addend ^ 0x80) - 0x80;
2633 addend += 1;
2634 }
2635 break;
2636 case 1:
2637 addend = bfd_get_16 (input_bfd, where);
2638 if (howto->pc_relative)
2639 {
2640 addend = (addend ^ 0x8000) - 0x8000;
2641 addend += 2;
2642 }
2643 break;
2644 case 2:
2645 addend = bfd_get_32 (input_bfd, where);
2646 if (howto->pc_relative)
2647 {
2648 addend = (addend ^ 0x80000000) - 0x80000000;
2649 addend += 4;
2650 }
2651 break;
2652 default:
2653 abort ();
2654 }
2655
2656 if (info->relocatable)
2657 addend += sec->output_offset;
2658 else
2659 {
2660 asection *msec = sec;
2661 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2662 addend);
2663 addend -= relocation;
2664 addend += msec->output_section->vma + msec->output_offset;
2665 }
2666
2667 switch (howto->size)
2668 {
2669 case 0:
2670 /* FIXME: overflow checks. */
2671 if (howto->pc_relative)
2672 addend -= 1;
2673 bfd_put_8 (input_bfd, addend, where);
2674 break;
2675 case 1:
2676 if (howto->pc_relative)
2677 addend -= 2;
2678 bfd_put_16 (input_bfd, addend, where);
2679 break;
2680 case 2:
2681 if (howto->pc_relative)
2682 addend -= 4;
2683 bfd_put_32 (input_bfd, addend, where);
2684 break;
2685 }
2686 }
2687 }
2688 else
2689 {
2690 bfd_boolean warned;
2691
2692 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2693 r_symndx, symtab_hdr, sym_hashes,
2694 h, sec, relocation,
2695 unresolved_reloc, warned);
2696 }
2697
2698 if (sec != NULL && elf_discarded_section (sec))
2699 {
2700 /* For relocs against symbols from removed linkonce sections,
2701 or sections discarded by a linker script, we just want the
2702 section contents zeroed. Avoid any special processing. */
2703 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2704 rel->r_info = 0;
2705 rel->r_addend = 0;
2706 continue;
2707 }
2708
2709 if (info->relocatable)
2710 continue;
2711
2712 switch (r_type)
2713 {
2714 case R_386_GOT32:
2715 /* Relocation is to the entry for this symbol in the global
2716 offset table. */
2717 if (htab->sgot == NULL)
2718 abort ();
2719
2720 if (h != NULL)
2721 {
2722 bfd_boolean dyn;
2723
2724 off = h->got.offset;
2725 dyn = htab->elf.dynamic_sections_created;
2726 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2727 || (info->shared
2728 && SYMBOL_REFERENCES_LOCAL (info, h))
2729 || (ELF_ST_VISIBILITY (h->other)
2730 && h->root.type == bfd_link_hash_undefweak))
2731 {
2732 /* This is actually a static link, or it is a
2733 -Bsymbolic link and the symbol is defined
2734 locally, or the symbol was forced to be local
2735 because of a version file. We must initialize
2736 this entry in the global offset table. Since the
2737 offset must always be a multiple of 4, we use the
2738 least significant bit to record whether we have
2739 initialized it already.
2740
2741 When doing a dynamic link, we create a .rel.got
2742 relocation entry to initialize the value. This
2743 is done in the finish_dynamic_symbol routine. */
2744 if ((off & 1) != 0)
2745 off &= ~1;
2746 else
2747 {
2748 bfd_put_32 (output_bfd, relocation,
2749 htab->sgot->contents + off);
2750 h->got.offset |= 1;
2751 }
2752 }
2753 else
2754 unresolved_reloc = FALSE;
2755 }
2756 else
2757 {
2758 if (local_got_offsets == NULL)
2759 abort ();
2760
2761 off = local_got_offsets[r_symndx];
2762
2763 /* The offset must always be a multiple of 4. We use
2764 the least significant bit to record whether we have
2765 already generated the necessary reloc. */
2766 if ((off & 1) != 0)
2767 off &= ~1;
2768 else
2769 {
2770 bfd_put_32 (output_bfd, relocation,
2771 htab->sgot->contents + off);
2772
2773 if (info->shared)
2774 {
2775 asection *s;
2776 Elf_Internal_Rela outrel;
2777 bfd_byte *loc;
2778
2779 s = htab->srelgot;
2780 if (s == NULL)
2781 abort ();
2782
2783 outrel.r_offset = (htab->sgot->output_section->vma
2784 + htab->sgot->output_offset
2785 + off);
2786 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2787 loc = s->contents;
2788 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2789 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2790 }
2791
2792 local_got_offsets[r_symndx] |= 1;
2793 }
2794 }
2795
2796 if (off >= (bfd_vma) -2)
2797 abort ();
2798
2799 relocation = htab->sgot->output_section->vma
2800 + htab->sgot->output_offset + off
2801 - htab->sgotplt->output_section->vma
2802 - htab->sgotplt->output_offset;
2803 break;
2804
2805 case R_386_GOTOFF:
2806 /* Relocation is relative to the start of the global offset
2807 table. */
2808
2809 /* Check to make sure it isn't a protected function symbol
2810 for shared library since it may not be local when used
2811 as function address. We also need to make sure that a
2812 symbol is defined locally. */
2813 if (info->shared && h)
2814 {
2815 if (!h->def_regular)
2816 {
2817 const char *v;
2818
2819 switch (ELF_ST_VISIBILITY (h->other))
2820 {
2821 case STV_HIDDEN:
2822 v = _("hidden symbol");
2823 break;
2824 case STV_INTERNAL:
2825 v = _("internal symbol");
2826 break;
2827 case STV_PROTECTED:
2828 v = _("protected symbol");
2829 break;
2830 default:
2831 v = _("symbol");
2832 break;
2833 }
2834
2835 (*_bfd_error_handler)
2836 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
2837 input_bfd, v, h->root.root.string);
2838 bfd_set_error (bfd_error_bad_value);
2839 return FALSE;
2840 }
2841 else if (!info->executable
2842 && h->type == STT_FUNC
2843 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2844 {
2845 (*_bfd_error_handler)
2846 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2847 input_bfd, h->root.root.string);
2848 bfd_set_error (bfd_error_bad_value);
2849 return FALSE;
2850 }
2851 }
2852
2853 /* Note that sgot is not involved in this
2854 calculation. We always want the start of .got.plt. If we
2855 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2856 permitted by the ABI, we might have to change this
2857 calculation. */
2858 relocation -= htab->sgotplt->output_section->vma
2859 + htab->sgotplt->output_offset;
2860 break;
2861
2862 case R_386_GOTPC:
2863 /* Use global offset table as symbol value. */
2864 relocation = htab->sgotplt->output_section->vma
2865 + htab->sgotplt->output_offset;
2866 unresolved_reloc = FALSE;
2867 break;
2868
2869 case R_386_PLT32:
2870 /* Relocation is to the entry for this symbol in the
2871 procedure linkage table. */
2872
2873 /* Resolve a PLT32 reloc against a local symbol directly,
2874 without using the procedure linkage table. */
2875 if (h == NULL)
2876 break;
2877
2878 if (h->plt.offset == (bfd_vma) -1
2879 || htab->splt == NULL)
2880 {
2881 /* We didn't make a PLT entry for this symbol. This
2882 happens when statically linking PIC code, or when
2883 using -Bsymbolic. */
2884 break;
2885 }
2886
2887 relocation = (htab->splt->output_section->vma
2888 + htab->splt->output_offset
2889 + h->plt.offset);
2890 unresolved_reloc = FALSE;
2891 break;
2892
2893 case R_386_32:
2894 case R_386_PC32:
2895 if ((input_section->flags & SEC_ALLOC) == 0
2896 || is_vxworks_tls)
2897 break;
2898
2899 if ((info->shared
2900 && (h == NULL
2901 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2902 || h->root.type != bfd_link_hash_undefweak)
2903 && (r_type != R_386_PC32
2904 || !SYMBOL_CALLS_LOCAL (info, h)))
2905 || (ELIMINATE_COPY_RELOCS
2906 && !info->shared
2907 && h != NULL
2908 && h->dynindx != -1
2909 && !h->non_got_ref
2910 && ((h->def_dynamic
2911 && !h->def_regular)
2912 || h->root.type == bfd_link_hash_undefweak
2913 || h->root.type == bfd_link_hash_undefined)))
2914 {
2915 Elf_Internal_Rela outrel;
2916 bfd_byte *loc;
2917 bfd_boolean skip, relocate;
2918 asection *sreloc;
2919
2920 /* When generating a shared object, these relocations
2921 are copied into the output file to be resolved at run
2922 time. */
2923
2924 skip = FALSE;
2925 relocate = FALSE;
2926
2927 outrel.r_offset =
2928 _bfd_elf_section_offset (output_bfd, info, input_section,
2929 rel->r_offset);
2930 if (outrel.r_offset == (bfd_vma) -1)
2931 skip = TRUE;
2932 else if (outrel.r_offset == (bfd_vma) -2)
2933 skip = TRUE, relocate = TRUE;
2934 outrel.r_offset += (input_section->output_section->vma
2935 + input_section->output_offset);
2936
2937 if (skip)
2938 memset (&outrel, 0, sizeof outrel);
2939 else if (h != NULL
2940 && h->dynindx != -1
2941 && (r_type == R_386_PC32
2942 || !info->shared
2943 || !SYMBOLIC_BIND (info, h)
2944 || !h->def_regular))
2945 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2946 else
2947 {
2948 /* This symbol is local, or marked to become local. */
2949 relocate = TRUE;
2950 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2951 }
2952
2953 sreloc = elf_section_data (input_section)->sreloc;
2954 if (sreloc == NULL)
2955 abort ();
2956
2957 loc = sreloc->contents;
2958 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2959 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2960
2961 /* If this reloc is against an external symbol, we do
2962 not want to fiddle with the addend. Otherwise, we
2963 need to include the symbol value so that it becomes
2964 an addend for the dynamic reloc. */
2965 if (! relocate)
2966 continue;
2967 }
2968 break;
2969
2970 case R_386_TLS_IE:
2971 if (info->shared)
2972 {
2973 Elf_Internal_Rela outrel;
2974 bfd_byte *loc;
2975 asection *sreloc;
2976
2977 outrel.r_offset = rel->r_offset
2978 + input_section->output_section->vma
2979 + input_section->output_offset;
2980 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2981 sreloc = elf_section_data (input_section)->sreloc;
2982 if (sreloc == NULL)
2983 abort ();
2984 loc = sreloc->contents;
2985 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2986 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2987 }
2988 /* Fall through */
2989
2990 case R_386_TLS_GD:
2991 case R_386_TLS_GOTDESC:
2992 case R_386_TLS_DESC_CALL:
2993 case R_386_TLS_IE_32:
2994 case R_386_TLS_GOTIE:
2995 tls_type = GOT_UNKNOWN;
2996 if (h == NULL && local_got_offsets)
2997 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2998 else if (h != NULL)
2999 tls_type = elf_i386_hash_entry(h)->tls_type;
3000 if (tls_type == GOT_TLS_IE)
3001 tls_type = GOT_TLS_IE_NEG;
3002
3003 if (! elf_i386_tls_transition (info, input_bfd,
3004 input_section, contents,
3005 symtab_hdr, sym_hashes,
3006 &r_type, tls_type, rel,
3007 relend, h))
3008 return FALSE;
3009
3010 if (r_type == R_386_TLS_LE_32)
3011 {
3012 BFD_ASSERT (! unresolved_reloc);
3013 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3014 {
3015 unsigned int type;
3016 bfd_vma roff;
3017
3018 /* GD->LE transition. */
3019 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3020 if (type == 0x04)
3021 {
3022 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3023 Change it into:
3024 movl %gs:0, %eax; subl $foo@tpoff, %eax
3025 (6 byte form of subl). */
3026 memcpy (contents + rel->r_offset - 3,
3027 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3028 roff = rel->r_offset + 5;
3029 }
3030 else
3031 {
3032 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3033 Change it into:
3034 movl %gs:0, %eax; subl $foo@tpoff, %eax
3035 (6 byte form of subl). */
3036 memcpy (contents + rel->r_offset - 2,
3037 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3038 roff = rel->r_offset + 6;
3039 }
3040 bfd_put_32 (output_bfd, tpoff (info, relocation),
3041 contents + roff);
3042 /* Skip R_386_PC32/R_386_PLT32. */
3043 rel++;
3044 continue;
3045 }
3046 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3047 {
3048 /* GDesc -> LE transition.
3049 It's originally something like:
3050 leal x@tlsdesc(%ebx), %eax
3051
3052 leal x@ntpoff, %eax
3053
3054 Registers other than %eax may be set up here. */
3055
3056 unsigned int val;
3057 bfd_vma roff;
3058
3059 roff = rel->r_offset;
3060 val = bfd_get_8 (input_bfd, contents + roff - 1);
3061
3062 /* Now modify the instruction as appropriate. */
3063 /* aoliva FIXME: remove the above and xor the byte
3064 below with 0x86. */
3065 bfd_put_8 (output_bfd, val ^ 0x86,
3066 contents + roff - 1);
3067 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3068 contents + roff);
3069 continue;
3070 }
3071 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3072 {
3073 /* GDesc -> LE transition.
3074 It's originally:
3075 call *(%eax)
3076 Turn it into:
3077 xchg %ax,%ax */
3078
3079 bfd_vma roff;
3080
3081 roff = rel->r_offset;
3082 bfd_put_8 (output_bfd, 0x66, contents + roff);
3083 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3084 continue;
3085 }
3086 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3087 {
3088 unsigned int val;
3089
3090 /* IE->LE transition:
3091 Originally it can be one of:
3092 movl foo, %eax
3093 movl foo, %reg
3094 addl foo, %reg
3095 We change it into:
3096 movl $foo, %eax
3097 movl $foo, %reg
3098 addl $foo, %reg. */
3099 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3100 if (val == 0xa1)
3101 {
3102 /* movl foo, %eax. */
3103 bfd_put_8 (output_bfd, 0xb8,
3104 contents + rel->r_offset - 1);
3105 }
3106 else
3107 {
3108 unsigned int type;
3109
3110 type = bfd_get_8 (input_bfd,
3111 contents + rel->r_offset - 2);
3112 switch (type)
3113 {
3114 case 0x8b:
3115 /* movl */
3116 bfd_put_8 (output_bfd, 0xc7,
3117 contents + rel->r_offset - 2);
3118 bfd_put_8 (output_bfd,
3119 0xc0 | ((val >> 3) & 7),
3120 contents + rel->r_offset - 1);
3121 break;
3122 case 0x03:
3123 /* addl */
3124 bfd_put_8 (output_bfd, 0x81,
3125 contents + rel->r_offset - 2);
3126 bfd_put_8 (output_bfd,
3127 0xc0 | ((val >> 3) & 7),
3128 contents + rel->r_offset - 1);
3129 break;
3130 default:
3131 BFD_FAIL ();
3132 break;
3133 }
3134 }
3135 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3136 contents + rel->r_offset);
3137 continue;
3138 }
3139 else
3140 {
3141 unsigned int val, type;
3142
3143 /* {IE_32,GOTIE}->LE transition:
3144 Originally it can be one of:
3145 subl foo(%reg1), %reg2
3146 movl foo(%reg1), %reg2
3147 addl foo(%reg1), %reg2
3148 We change it into:
3149 subl $foo, %reg2
3150 movl $foo, %reg2 (6 byte form)
3151 addl $foo, %reg2. */
3152 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3153 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3154 if (type == 0x8b)
3155 {
3156 /* movl */
3157 bfd_put_8 (output_bfd, 0xc7,
3158 contents + rel->r_offset - 2);
3159 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3160 contents + rel->r_offset - 1);
3161 }
3162 else if (type == 0x2b)
3163 {
3164 /* subl */
3165 bfd_put_8 (output_bfd, 0x81,
3166 contents + rel->r_offset - 2);
3167 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3168 contents + rel->r_offset - 1);
3169 }
3170 else if (type == 0x03)
3171 {
3172 /* addl */
3173 bfd_put_8 (output_bfd, 0x81,
3174 contents + rel->r_offset - 2);
3175 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3176 contents + rel->r_offset - 1);
3177 }
3178 else
3179 BFD_FAIL ();
3180 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3181 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3182 contents + rel->r_offset);
3183 else
3184 bfd_put_32 (output_bfd, tpoff (info, relocation),
3185 contents + rel->r_offset);
3186 continue;
3187 }
3188 }
3189
3190 if (htab->sgot == NULL)
3191 abort ();
3192
3193 if (h != NULL)
3194 {
3195 off = h->got.offset;
3196 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3197 }
3198 else
3199 {
3200 if (local_got_offsets == NULL)
3201 abort ();
3202
3203 off = local_got_offsets[r_symndx];
3204 offplt = local_tlsdesc_gotents[r_symndx];
3205 }
3206
3207 if ((off & 1) != 0)
3208 off &= ~1;
3209 else
3210 {
3211 Elf_Internal_Rela outrel;
3212 bfd_byte *loc;
3213 int dr_type, indx;
3214 asection *sreloc;
3215
3216 if (htab->srelgot == NULL)
3217 abort ();
3218
3219 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3220
3221 if (GOT_TLS_GDESC_P (tls_type))
3222 {
3223 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3224 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3225 <= htab->sgotplt->size);
3226 outrel.r_offset = (htab->sgotplt->output_section->vma
3227 + htab->sgotplt->output_offset
3228 + offplt
3229 + htab->sgotplt_jump_table_size);
3230 sreloc = htab->srelplt;
3231 loc = sreloc->contents;
3232 loc += (htab->next_tls_desc_index++
3233 * sizeof (Elf32_External_Rel));
3234 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3235 <= sreloc->contents + sreloc->size);
3236 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3237 if (indx == 0)
3238 {
3239 BFD_ASSERT (! unresolved_reloc);
3240 bfd_put_32 (output_bfd,
3241 relocation - dtpoff_base (info),
3242 htab->sgotplt->contents + offplt
3243 + htab->sgotplt_jump_table_size + 4);
3244 }
3245 else
3246 {
3247 bfd_put_32 (output_bfd, 0,
3248 htab->sgotplt->contents + offplt
3249 + htab->sgotplt_jump_table_size + 4);
3250 }
3251 }
3252
3253 sreloc = htab->srelgot;
3254
3255 outrel.r_offset = (htab->sgot->output_section->vma
3256 + htab->sgot->output_offset + off);
3257
3258 if (GOT_TLS_GD_P (tls_type))
3259 dr_type = R_386_TLS_DTPMOD32;
3260 else if (GOT_TLS_GDESC_P (tls_type))
3261 goto dr_done;
3262 else if (tls_type == GOT_TLS_IE_POS)
3263 dr_type = R_386_TLS_TPOFF;
3264 else
3265 dr_type = R_386_TLS_TPOFF32;
3266
3267 if (dr_type == R_386_TLS_TPOFF && indx == 0)
3268 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3269 htab->sgot->contents + off);
3270 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3271 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
3272 htab->sgot->contents + off);
3273 else if (dr_type != R_386_TLS_DESC)
3274 bfd_put_32 (output_bfd, 0,
3275 htab->sgot->contents + off);
3276 outrel.r_info = ELF32_R_INFO (indx, dr_type);
3277
3278 loc = sreloc->contents;
3279 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3280 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3281 <= sreloc->contents + sreloc->size);
3282 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3283
3284 if (GOT_TLS_GD_P (tls_type))
3285 {
3286 if (indx == 0)
3287 {
3288 BFD_ASSERT (! unresolved_reloc);
3289 bfd_put_32 (output_bfd,
3290 relocation - dtpoff_base (info),
3291 htab->sgot->contents + off + 4);
3292 }
3293 else
3294 {
3295 bfd_put_32 (output_bfd, 0,
3296 htab->sgot->contents + off + 4);
3297 outrel.r_info = ELF32_R_INFO (indx,
3298 R_386_TLS_DTPOFF32);
3299 outrel.r_offset += 4;
3300 sreloc->reloc_count++;
3301 loc += sizeof (Elf32_External_Rel);
3302 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3303 <= sreloc->contents + sreloc->size);
3304 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3305 }
3306 }
3307 else if (tls_type == GOT_TLS_IE_BOTH)
3308 {
3309 bfd_put_32 (output_bfd,
3310 indx == 0 ? relocation - dtpoff_base (info) : 0,
3311 htab->sgot->contents + off + 4);
3312 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3313 outrel.r_offset += 4;
3314 sreloc->reloc_count++;
3315 loc += sizeof (Elf32_External_Rel);
3316 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3317 }
3318
3319 dr_done:
3320 if (h != NULL)
3321 h->got.offset |= 1;
3322 else
3323 local_got_offsets[r_symndx] |= 1;
3324 }
3325
3326 if (off >= (bfd_vma) -2
3327 && ! GOT_TLS_GDESC_P (tls_type))
3328 abort ();
3329 if (r_type == R_386_TLS_GOTDESC
3330 || r_type == R_386_TLS_DESC_CALL)
3331 {
3332 relocation = htab->sgotplt_jump_table_size + offplt;
3333 unresolved_reloc = FALSE;
3334 }
3335 else if (r_type == ELF32_R_TYPE (rel->r_info))
3336 {
3337 bfd_vma g_o_t = htab->sgotplt->output_section->vma
3338 + htab->sgotplt->output_offset;
3339 relocation = htab->sgot->output_section->vma
3340 + htab->sgot->output_offset + off - g_o_t;
3341 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3342 && tls_type == GOT_TLS_IE_BOTH)
3343 relocation += 4;
3344 if (r_type == R_386_TLS_IE)
3345 relocation += g_o_t;
3346 unresolved_reloc = FALSE;
3347 }
3348 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3349 {
3350 unsigned int val, type;
3351 bfd_vma roff;
3352
3353 /* GD->IE transition. */
3354 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3355 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3356 if (type == 0x04)
3357 {
3358 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3359 Change it into:
3360 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3361 val >>= 3;
3362 roff = rel->r_offset - 3;
3363 }
3364 else
3365 {
3366 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3367 Change it into:
3368 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3369 roff = rel->r_offset - 2;
3370 }
3371 memcpy (contents + roff,
3372 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3373 contents[roff + 7] = 0x80 | (val & 7);
3374 /* If foo is used only with foo@gotntpoff(%reg) and
3375 foo@indntpoff, but not with foo@gottpoff(%reg), change
3376 subl $foo@gottpoff(%reg), %eax
3377 into:
3378 addl $foo@gotntpoff(%reg), %eax. */
3379 if (tls_type == GOT_TLS_IE_POS)
3380 contents[roff + 6] = 0x03;
3381 bfd_put_32 (output_bfd,
3382 htab->sgot->output_section->vma
3383 + htab->sgot->output_offset + off
3384 - htab->sgotplt->output_section->vma
3385 - htab->sgotplt->output_offset,
3386 contents + roff + 8);
3387 /* Skip R_386_PLT32. */
3388 rel++;
3389 continue;
3390 }
3391 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3392 {
3393 /* GDesc -> IE transition.
3394 It's originally something like:
3395 leal x@tlsdesc(%ebx), %eax
3396
3397 Change it to:
3398 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3399 or:
3400 movl x@gottpoff(%ebx), %eax # before negl %eax
3401
3402 Registers other than %eax may be set up here. */
3403
3404 bfd_vma roff;
3405
3406 /* First, make sure it's a leal adding ebx to a 32-bit
3407 offset into any register, although it's probably
3408 almost always going to be eax. */
3409 roff = rel->r_offset;
3410
3411 /* Now modify the instruction as appropriate. */
3412 /* To turn a leal into a movl in the form we use it, it
3413 suffices to change the first byte from 0x8d to 0x8b.
3414 aoliva FIXME: should we decide to keep the leal, all
3415 we have to do is remove the statement below, and
3416 adjust the relaxation of R_386_TLS_DESC_CALL. */
3417 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3418
3419 if (tls_type == GOT_TLS_IE_BOTH)
3420 off += 4;
3421
3422 bfd_put_32 (output_bfd,
3423 htab->sgot->output_section->vma
3424 + htab->sgot->output_offset + off
3425 - htab->sgotplt->output_section->vma
3426 - htab->sgotplt->output_offset,
3427 contents + roff);
3428 continue;
3429 }
3430 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3431 {
3432 /* GDesc -> IE transition.
3433 It's originally:
3434 call *(%eax)
3435
3436 Change it to:
3437 xchg %ax,%ax
3438 or
3439 negl %eax
3440 depending on how we transformed the TLS_GOTDESC above.
3441 */
3442
3443 bfd_vma roff;
3444
3445 roff = rel->r_offset;
3446
3447 /* Now modify the instruction as appropriate. */
3448 if (tls_type != GOT_TLS_IE_NEG)
3449 {
3450 /* xchg %ax,%ax */
3451 bfd_put_8 (output_bfd, 0x66, contents + roff);
3452 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3453 }
3454 else
3455 {
3456 /* negl %eax */
3457 bfd_put_8 (output_bfd, 0xf7, contents + roff);
3458 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3459 }
3460
3461 continue;
3462 }
3463 else
3464 BFD_ASSERT (FALSE);
3465 break;
3466
3467 case R_386_TLS_LDM:
3468 if (! elf_i386_tls_transition (info, input_bfd,
3469 input_section, contents,
3470 symtab_hdr, sym_hashes,
3471 &r_type, GOT_UNKNOWN, rel,
3472 relend, h))
3473 return FALSE;
3474
3475 if (r_type != R_386_TLS_LDM)
3476 {
3477 /* LD->LE transition:
3478 leal foo(%reg), %eax; call ___tls_get_addr.
3479 We change it into:
3480 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3481 BFD_ASSERT (r_type == R_386_TLS_LE_32);
3482 memcpy (contents + rel->r_offset - 2,
3483 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3484 /* Skip R_386_PC32/R_386_PLT32. */
3485 rel++;
3486 continue;
3487 }
3488
3489 if (htab->sgot == NULL)
3490 abort ();
3491
3492 off = htab->tls_ldm_got.offset;
3493 if (off & 1)
3494 off &= ~1;
3495 else
3496 {
3497 Elf_Internal_Rela outrel;
3498 bfd_byte *loc;
3499
3500 if (htab->srelgot == NULL)
3501 abort ();
3502
3503 outrel.r_offset = (htab->sgot->output_section->vma
3504 + htab->sgot->output_offset + off);
3505
3506 bfd_put_32 (output_bfd, 0,
3507 htab->sgot->contents + off);
3508 bfd_put_32 (output_bfd, 0,
3509 htab->sgot->contents + off + 4);
3510 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3511 loc = htab->srelgot->contents;
3512 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3513 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3514 htab->tls_ldm_got.offset |= 1;
3515 }
3516 relocation = htab->sgot->output_section->vma
3517 + htab->sgot->output_offset + off
3518 - htab->sgotplt->output_section->vma
3519 - htab->sgotplt->output_offset;
3520 unresolved_reloc = FALSE;
3521 break;
3522
3523 case R_386_TLS_LDO_32:
3524 if (info->shared || (input_section->flags & SEC_CODE) == 0)
3525 relocation -= dtpoff_base (info);
3526 else
3527 /* When converting LDO to LE, we must negate. */
3528 relocation = -tpoff (info, relocation);
3529 break;
3530
3531 case R_386_TLS_LE_32:
3532 case R_386_TLS_LE:
3533 if (info->shared)
3534 {
3535 Elf_Internal_Rela outrel;
3536 asection *sreloc;
3537 bfd_byte *loc;
3538 int indx;
3539
3540 outrel.r_offset = rel->r_offset
3541 + input_section->output_section->vma
3542 + input_section->output_offset;
3543 if (h != NULL && h->dynindx != -1)
3544 indx = h->dynindx;
3545 else
3546 indx = 0;
3547 if (r_type == R_386_TLS_LE_32)
3548 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3549 else
3550 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3551 sreloc = elf_section_data (input_section)->sreloc;
3552 if (sreloc == NULL)
3553 abort ();
3554 loc = sreloc->contents;
3555 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3556 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3557 if (indx)
3558 continue;
3559 else if (r_type == R_386_TLS_LE_32)
3560 relocation = dtpoff_base (info) - relocation;
3561 else
3562 relocation -= dtpoff_base (info);
3563 }
3564 else if (r_type == R_386_TLS_LE_32)
3565 relocation = tpoff (info, relocation);
3566 else
3567 relocation = -tpoff (info, relocation);
3568 break;
3569
3570 default:
3571 break;
3572 }
3573
3574 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3575 because such sections are not SEC_ALLOC and thus ld.so will
3576 not process them. */
3577 if (unresolved_reloc
3578 && !((input_section->flags & SEC_DEBUGGING) != 0
3579 && h->def_dynamic))
3580 {
3581 (*_bfd_error_handler)
3582 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3583 input_bfd,
3584 input_section,
3585 (long) rel->r_offset,
3586 howto->name,
3587 h->root.root.string);
3588 return FALSE;
3589 }
3590
3591 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3592 contents, rel->r_offset,
3593 relocation, 0);
3594
3595 if (r != bfd_reloc_ok)
3596 {
3597 const char *name;
3598
3599 if (h != NULL)
3600 name = h->root.root.string;
3601 else
3602 {
3603 name = bfd_elf_string_from_elf_section (input_bfd,
3604 symtab_hdr->sh_link,
3605 sym->st_name);
3606 if (name == NULL)
3607 return FALSE;
3608 if (*name == '\0')
3609 name = bfd_section_name (input_bfd, sec);
3610 }
3611
3612 if (r == bfd_reloc_overflow)
3613 {
3614 if (! ((*info->callbacks->reloc_overflow)
3615 (info, (h ? &h->root : NULL), name, howto->name,
3616 (bfd_vma) 0, input_bfd, input_section,
3617 rel->r_offset)))
3618 return FALSE;
3619 }
3620 else
3621 {
3622 (*_bfd_error_handler)
3623 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3624 input_bfd, input_section,
3625 (long) rel->r_offset, name, (int) r);
3626 return FALSE;
3627 }
3628 }
3629 }
3630
3631 return TRUE;
3632 }
3633
3634 /* Finish up dynamic symbol handling. We set the contents of various
3635 dynamic sections here. */
3636
3637 static bfd_boolean
3638 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3639 struct bfd_link_info *info,
3640 struct elf_link_hash_entry *h,
3641 Elf_Internal_Sym *sym)
3642 {
3643 struct elf_i386_link_hash_table *htab;
3644
3645 htab = elf_i386_hash_table (info);
3646
3647 if (h->plt.offset != (bfd_vma) -1)
3648 {
3649 bfd_vma plt_index;
3650 bfd_vma got_offset;
3651 Elf_Internal_Rela rel;
3652 bfd_byte *loc;
3653
3654 /* This symbol has an entry in the procedure linkage table. Set
3655 it up. */
3656
3657 if (h->dynindx == -1
3658 || htab->splt == NULL
3659 || htab->sgotplt == NULL
3660 || htab->srelplt == NULL)
3661 abort ();
3662
3663 /* Get the index in the procedure linkage table which
3664 corresponds to this symbol. This is the index of this symbol
3665 in all the symbols for which we are making plt entries. The
3666 first entry in the procedure linkage table is reserved. */
3667 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3668
3669 /* Get the offset into the .got table of the entry that
3670 corresponds to this function. Each .got entry is 4 bytes.
3671 The first three are reserved. */
3672 got_offset = (plt_index + 3) * 4;
3673
3674 /* Fill in the entry in the procedure linkage table. */
3675 if (! info->shared)
3676 {
3677 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3678 PLT_ENTRY_SIZE);
3679 bfd_put_32 (output_bfd,
3680 (htab->sgotplt->output_section->vma
3681 + htab->sgotplt->output_offset
3682 + got_offset),
3683 htab->splt->contents + h->plt.offset + 2);
3684
3685 if (htab->is_vxworks)
3686 {
3687 int s, k, reloc_index;
3688
3689 /* Create the R_386_32 relocation referencing the GOT
3690 for this PLT entry. */
3691
3692 /* S: Current slot number (zero-based). */
3693 s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3694 /* K: Number of relocations for PLTResolve. */
3695 if (info->shared)
3696 k = PLTRESOLVE_RELOCS_SHLIB;
3697 else
3698 k = PLTRESOLVE_RELOCS;
3699 /* Skip the PLTresolve relocations, and the relocations for
3700 the other PLT slots. */
3701 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3702 loc = (htab->srelplt2->contents + reloc_index
3703 * sizeof (Elf32_External_Rel));
3704
3705 rel.r_offset = (htab->splt->output_section->vma
3706 + htab->splt->output_offset
3707 + h->plt.offset + 2),
3708 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3709 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3710
3711 /* Create the R_386_32 relocation referencing the beginning of
3712 the PLT for this GOT entry. */
3713 rel.r_offset = (htab->sgotplt->output_section->vma
3714 + htab->sgotplt->output_offset
3715 + got_offset);
3716 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3717 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3718 loc + sizeof (Elf32_External_Rel));
3719 }
3720 }
3721 else
3722 {
3723 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3724 PLT_ENTRY_SIZE);
3725 bfd_put_32 (output_bfd, got_offset,
3726 htab->splt->contents + h->plt.offset + 2);
3727 }
3728
3729 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3730 htab->splt->contents + h->plt.offset + 7);
3731 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3732 htab->splt->contents + h->plt.offset + 12);
3733
3734 /* Fill in the entry in the global offset table. */
3735 bfd_put_32 (output_bfd,
3736 (htab->splt->output_section->vma
3737 + htab->splt->output_offset
3738 + h->plt.offset
3739 + 6),
3740 htab->sgotplt->contents + got_offset);
3741
3742 /* Fill in the entry in the .rel.plt section. */
3743 rel.r_offset = (htab->sgotplt->output_section->vma
3744 + htab->sgotplt->output_offset
3745 + got_offset);
3746 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3747 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3748 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3749
3750 if (!h->def_regular)
3751 {
3752 /* Mark the symbol as undefined, rather than as defined in
3753 the .plt section. Leave the value if there were any
3754 relocations where pointer equality matters (this is a clue
3755 for the dynamic linker, to make function pointer
3756 comparisons work between an application and shared
3757 library), otherwise set it to zero. If a function is only
3758 called from a binary, there is no need to slow down
3759 shared libraries because of that. */
3760 sym->st_shndx = SHN_UNDEF;
3761 if (!h->pointer_equality_needed)
3762 sym->st_value = 0;
3763 }
3764 }
3765
3766 if (h->got.offset != (bfd_vma) -1
3767 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
3768 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3769 {
3770 Elf_Internal_Rela rel;
3771 bfd_byte *loc;
3772
3773 /* This symbol has an entry in the global offset table. Set it
3774 up. */
3775
3776 if (htab->sgot == NULL || htab->srelgot == NULL)
3777 abort ();
3778
3779 rel.r_offset = (htab->sgot->output_section->vma
3780 + htab->sgot->output_offset
3781 + (h->got.offset & ~(bfd_vma) 1));
3782
3783 /* If this is a static link, or it is a -Bsymbolic link and the
3784 symbol is defined locally or was forced to be local because
3785 of a version file, we just want to emit a RELATIVE reloc.
3786 The entry in the global offset table will already have been
3787 initialized in the relocate_section function. */
3788 if (info->shared
3789 && SYMBOL_REFERENCES_LOCAL (info, h))
3790 {
3791 BFD_ASSERT((h->got.offset & 1) != 0);
3792 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3793 }
3794 else
3795 {
3796 BFD_ASSERT((h->got.offset & 1) == 0);
3797 bfd_put_32 (output_bfd, (bfd_vma) 0,
3798 htab->sgot->contents + h->got.offset);
3799 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3800 }
3801
3802 loc = htab->srelgot->contents;
3803 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3804 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3805 }
3806
3807 if (h->needs_copy)
3808 {
3809 Elf_Internal_Rela rel;
3810 bfd_byte *loc;
3811
3812 /* This symbol needs a copy reloc. Set it up. */
3813
3814 if (h->dynindx == -1
3815 || (h->root.type != bfd_link_hash_defined
3816 && h->root.type != bfd_link_hash_defweak)
3817 || htab->srelbss == NULL)
3818 abort ();
3819
3820 rel.r_offset = (h->root.u.def.value
3821 + h->root.u.def.section->output_section->vma
3822 + h->root.u.def.section->output_offset);
3823 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3824 loc = htab->srelbss->contents;
3825 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3826 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3827 }
3828
3829 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3830 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3831 is relative to the ".got" section. */
3832 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3833 || (!htab->is_vxworks && h == htab->elf.hgot))
3834 sym->st_shndx = SHN_ABS;
3835
3836 return TRUE;
3837 }
3838
3839 /* Used to decide how to sort relocs in an optimal manner for the
3840 dynamic linker, before writing them out. */
3841
3842 static enum elf_reloc_type_class
3843 elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
3844 {
3845 switch (ELF32_R_TYPE (rela->r_info))
3846 {
3847 case R_386_RELATIVE:
3848 return reloc_class_relative;
3849 case R_386_JUMP_SLOT:
3850 return reloc_class_plt;
3851 case R_386_COPY:
3852 return reloc_class_copy;
3853 default:
3854 return reloc_class_normal;
3855 }
3856 }
3857
3858 /* Finish up the dynamic sections. */
3859
3860 static bfd_boolean
3861 elf_i386_finish_dynamic_sections (bfd *output_bfd,
3862 struct bfd_link_info *info)
3863 {
3864 struct elf_i386_link_hash_table *htab;
3865 bfd *dynobj;
3866 asection *sdyn;
3867
3868 htab = elf_i386_hash_table (info);
3869 dynobj = htab->elf.dynobj;
3870 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3871
3872 if (htab->elf.dynamic_sections_created)
3873 {
3874 Elf32_External_Dyn *dyncon, *dynconend;
3875
3876 if (sdyn == NULL || htab->sgot == NULL)
3877 abort ();
3878
3879 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3880 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3881 for (; dyncon < dynconend; dyncon++)
3882 {
3883 Elf_Internal_Dyn dyn;
3884 asection *s;
3885
3886 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3887
3888 switch (dyn.d_tag)
3889 {
3890 default:
3891 if (htab->is_vxworks
3892 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
3893 break;
3894 continue;
3895
3896 case DT_PLTGOT:
3897 s = htab->sgotplt;
3898 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3899 break;
3900
3901 case DT_JMPREL:
3902 s = htab->srelplt;
3903 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3904 break;
3905
3906 case DT_PLTRELSZ:
3907 s = htab->srelplt;
3908 dyn.d_un.d_val = s->size;
3909 break;
3910
3911 case DT_RELSZ:
3912 /* My reading of the SVR4 ABI indicates that the
3913 procedure linkage table relocs (DT_JMPREL) should be
3914 included in the overall relocs (DT_REL). This is
3915 what Solaris does. However, UnixWare can not handle
3916 that case. Therefore, we override the DT_RELSZ entry
3917 here to make it not include the JMPREL relocs. */
3918 s = htab->srelplt;
3919 if (s == NULL)
3920 continue;
3921 dyn.d_un.d_val -= s->size;
3922 break;
3923
3924 case DT_REL:
3925 /* We may not be using the standard ELF linker script.
3926 If .rel.plt is the first .rel section, we adjust
3927 DT_REL to not include it. */
3928 s = htab->srelplt;
3929 if (s == NULL)
3930 continue;
3931 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3932 continue;
3933 dyn.d_un.d_ptr += s->size;
3934 break;
3935 }
3936
3937 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3938 }
3939
3940 /* Fill in the first entry in the procedure linkage table. */
3941 if (htab->splt && htab->splt->size > 0)
3942 {
3943 if (info->shared)
3944 {
3945 memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3946 sizeof (elf_i386_pic_plt0_entry));
3947 memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3948 htab->plt0_pad_byte,
3949 PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3950 }
3951 else
3952 {
3953 memcpy (htab->splt->contents, elf_i386_plt0_entry,
3954 sizeof(elf_i386_plt0_entry));
3955 memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3956 htab->plt0_pad_byte,
3957 PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
3958 bfd_put_32 (output_bfd,
3959 (htab->sgotplt->output_section->vma
3960 + htab->sgotplt->output_offset
3961 + 4),
3962 htab->splt->contents + 2);
3963 bfd_put_32 (output_bfd,
3964 (htab->sgotplt->output_section->vma
3965 + htab->sgotplt->output_offset
3966 + 8),
3967 htab->splt->contents + 8);
3968
3969 if (htab->is_vxworks)
3970 {
3971 Elf_Internal_Rela rel;
3972
3973 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3974 On IA32 we use REL relocations so the addend goes in
3975 the PLT directly. */
3976 rel.r_offset = (htab->splt->output_section->vma
3977 + htab->splt->output_offset
3978 + 2);
3979 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3980 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3981 htab->srelplt2->contents);
3982 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
3983 rel.r_offset = (htab->splt->output_section->vma
3984 + htab->splt->output_offset
3985 + 8);
3986 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3987 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3988 htab->srelplt2->contents +
3989 sizeof (Elf32_External_Rel));
3990 }
3991 }
3992
3993 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3994 really seem like the right value. */
3995 elf_section_data (htab->splt->output_section)
3996 ->this_hdr.sh_entsize = 4;
3997
3998 /* Correct the .rel.plt.unloaded relocations. */
3999 if (htab->is_vxworks && !info->shared)
4000 {
4001 int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
4002 unsigned char *p;
4003
4004 p = htab->srelplt2->contents;
4005 if (info->shared)
4006 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4007 else
4008 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4009
4010 for (; num_plts; num_plts--)
4011 {
4012 Elf_Internal_Rela rel;
4013 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4014 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4015 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4016 p += sizeof (Elf32_External_Rel);
4017
4018 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4019 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4020 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4021 p += sizeof (Elf32_External_Rel);
4022 }
4023 }
4024 }
4025 }
4026
4027 if (htab->sgotplt)
4028 {
4029 /* Fill in the first three entries in the global offset table. */
4030 if (htab->sgotplt->size > 0)
4031 {
4032 bfd_put_32 (output_bfd,
4033 (sdyn == NULL ? 0
4034 : sdyn->output_section->vma + sdyn->output_offset),
4035 htab->sgotplt->contents);
4036 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
4037 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
4038 }
4039
4040 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
4041 }
4042
4043 if (htab->sgot && htab->sgot->size > 0)
4044 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
4045
4046 return TRUE;
4047 }
4048
4049 /* Return address for Ith PLT stub in section PLT, for relocation REL
4050 or (bfd_vma) -1 if it should not be included. */
4051
4052 static bfd_vma
4053 elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4054 const arelent *rel ATTRIBUTE_UNUSED)
4055 {
4056 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4057 }
4058
4059 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4060
4061 static bfd_boolean
4062 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4063 {
4064 if (h->plt.offset != (bfd_vma) -1
4065 && !h->def_regular
4066 && !h->pointer_equality_needed)
4067 return FALSE;
4068
4069 return _bfd_elf_hash_symbol (h);
4070 }
4071
4072 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4073 #define TARGET_LITTLE_NAME "elf32-i386"
4074 #define ELF_ARCH bfd_arch_i386
4075 #define ELF_MACHINE_CODE EM_386
4076 #define ELF_MAXPAGESIZE 0x1000
4077
4078 #define elf_backend_can_gc_sections 1
4079 #define elf_backend_can_refcount 1
4080 #define elf_backend_want_got_plt 1
4081 #define elf_backend_plt_readonly 1
4082 #define elf_backend_want_plt_sym 0
4083 #define elf_backend_got_header_size 12
4084
4085 /* Support RELA for objdump of prelink objects. */
4086 #define elf_info_to_howto elf_i386_info_to_howto_rel
4087 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4088
4089 #define bfd_elf32_mkobject elf_i386_mkobject
4090
4091 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4092 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
4093 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
4094 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
4095
4096 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
4097 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4098 #define elf_backend_check_relocs elf_i386_check_relocs
4099 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
4100 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
4101 #define elf_backend_fake_sections elf_i386_fake_sections
4102 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4103 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4104 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4105 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
4106 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
4107 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
4108 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
4109 #define elf_backend_relocate_section elf_i386_relocate_section
4110 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
4111 #define elf_backend_always_size_sections elf_i386_always_size_sections
4112 #define elf_backend_omit_section_dynsym \
4113 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4114 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
4115 #define elf_backend_hash_symbol elf_i386_hash_symbol
4116
4117 #include "elf32-target.h"
4118
4119 /* FreeBSD support. */
4120
4121 #undef TARGET_LITTLE_SYM
4122 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4123 #undef TARGET_LITTLE_NAME
4124 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
4125 #undef ELF_OSABI
4126 #define ELF_OSABI ELFOSABI_FREEBSD
4127
4128 /* The kernel recognizes executables as valid only if they carry a
4129 "FreeBSD" label in the ELF header. So we put this label on all
4130 executables and (for simplicity) also all other object files. */
4131
4132 static void
4133 elf_i386_post_process_headers (bfd *abfd,
4134 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4135 {
4136 Elf_Internal_Ehdr *i_ehdrp;
4137
4138 i_ehdrp = elf_elfheader (abfd);
4139
4140 /* Put an ABI label supported by FreeBSD >= 4.1. */
4141 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
4142 #ifdef OLD_FREEBSD_ABI_LABEL
4143 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4144 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
4145 #endif
4146 }
4147
4148 #undef elf_backend_post_process_headers
4149 #define elf_backend_post_process_headers elf_i386_post_process_headers
4150 #undef elf32_bed
4151 #define elf32_bed elf32_i386_fbsd_bed
4152
4153 #include "elf32-target.h"
4154
4155 /* VxWorks support. */
4156
4157 #undef TARGET_LITTLE_SYM
4158 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4159 #undef TARGET_LITTLE_NAME
4160 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
4161 #undef ELF_OSABI
4162
4163 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
4164
4165 static struct bfd_link_hash_table *
4166 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
4167 {
4168 struct bfd_link_hash_table *ret;
4169 struct elf_i386_link_hash_table *htab;
4170
4171 ret = elf_i386_link_hash_table_create (abfd);
4172 if (ret)
4173 {
4174 htab = (struct elf_i386_link_hash_table *) ret;
4175 htab->is_vxworks = 1;
4176 htab->plt0_pad_byte = 0x90;
4177 }
4178
4179 return ret;
4180 }
4181
4182
4183 #undef elf_backend_relocs_compatible
4184 #undef elf_backend_post_process_headers
4185 #undef bfd_elf32_bfd_link_hash_table_create
4186 #define bfd_elf32_bfd_link_hash_table_create \
4187 elf_i386_vxworks_link_hash_table_create
4188 #undef elf_backend_add_symbol_hook
4189 #define elf_backend_add_symbol_hook \
4190 elf_vxworks_add_symbol_hook
4191 #undef elf_backend_link_output_symbol_hook
4192 #define elf_backend_link_output_symbol_hook \
4193 elf_vxworks_link_output_symbol_hook
4194 #undef elf_backend_emit_relocs
4195 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4196 #undef elf_backend_final_write_processing
4197 #define elf_backend_final_write_processing \
4198 elf_vxworks_final_write_processing
4199
4200 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4201 define it. */
4202 #undef elf_backend_want_plt_sym
4203 #define elf_backend_want_plt_sym 1
4204
4205 #undef elf32_bed
4206 #define elf32_bed elf32_i386_vxworks_bed
4207
4208 #include "elf32-target.h"
git-cvsimport of binutils cvsroot