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