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