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