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