?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/bfin-parse.y (binary): Change sub of const to add of negated
[binutils.git] / bfd / elf32-i386.c
blob88f4de78ede9e422061511123e356f4ebb09fa67
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 if (abfd->tdata.any == NULL)
626 {
627 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
628 abfd->tdata.any = bfd_zalloc (abfd, amt);
629 if (abfd->tdata.any == NULL)
630 return FALSE;
631 }
632 return bfd_elf_mkobject (abfd);
633 }
634
635 /* i386 ELF linker hash table. */
636
637 struct elf_i386_link_hash_table
638 {
639 struct elf_link_hash_table elf;
640
641 /* Short-cuts to get to dynamic linker sections. */
642 asection *sgot;
643 asection *sgotplt;
644 asection *srelgot;
645 asection *splt;
646 asection *srelplt;
647 asection *sdynbss;
648 asection *srelbss;
649
650 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
651 asection *srelplt2;
652
653 /* True if the target system is VxWorks. */
654 int is_vxworks;
655
656 /* Value used to fill the last word of the first plt entry. */
657 bfd_byte plt0_pad_byte;
658
659 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
660 bfd_vma next_tls_desc_index;
661
662 union {
663 bfd_signed_vma refcount;
664 bfd_vma offset;
665 } tls_ldm_got;
666
667 /* The amount of space used by the reserved portion of the sgotplt
668 section, plus whatever space is used by the jump slots. */
669 bfd_vma sgotplt_jump_table_size;
670
671 /* Small local sym to section mapping cache. */
672 struct sym_sec_cache sym_sec;
673 };
674
675 /* Get the i386 ELF linker hash table from a link_info structure. */
676
677 #define elf_i386_hash_table(p) \
678 ((struct elf_i386_link_hash_table *) ((p)->hash))
679
680 #define elf_i386_compute_jump_table_size(htab) \
681 ((htab)->next_tls_desc_index * 4)
682
683 /* Create an entry in an i386 ELF linker hash table. */
684
685 static struct bfd_hash_entry *
686 link_hash_newfunc (struct bfd_hash_entry *entry,
687 struct bfd_hash_table *table,
688 const char *string)
689 {
690 /* Allocate the structure if it has not already been allocated by a
691 subclass. */
692 if (entry == NULL)
693 {
694 entry = bfd_hash_allocate (table,
695 sizeof (struct elf_i386_link_hash_entry));
696 if (entry == NULL)
697 return entry;
698 }
699
700 /* Call the allocation method of the superclass. */
701 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
702 if (entry != NULL)
703 {
704 struct elf_i386_link_hash_entry *eh;
705
706 eh = (struct elf_i386_link_hash_entry *) entry;
707 eh->dyn_relocs = NULL;
708 eh->tls_type = GOT_UNKNOWN;
709 eh->tlsdesc_got = (bfd_vma) -1;
710 }
711
712 return entry;
713 }
714
715 /* Create an i386 ELF linker hash table. */
716
717 static struct bfd_link_hash_table *
718 elf_i386_link_hash_table_create (bfd *abfd)
719 {
720 struct elf_i386_link_hash_table *ret;
721 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
722
723 ret = bfd_malloc (amt);
724 if (ret == NULL)
725 return NULL;
726
727 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
728 sizeof (struct elf_i386_link_hash_entry)))
729 {
730 free (ret);
731 return NULL;
732 }
733
734 ret->sgot = NULL;
735 ret->sgotplt = NULL;
736 ret->srelgot = NULL;
737 ret->splt = NULL;
738 ret->srelplt = NULL;
739 ret->sdynbss = NULL;
740 ret->srelbss = NULL;
741 ret->tls_ldm_got.refcount = 0;
742 ret->next_tls_desc_index = 0;
743 ret->sgotplt_jump_table_size = 0;
744 ret->sym_sec.abfd = NULL;
745 ret->is_vxworks = 0;
746 ret->srelplt2 = NULL;
747 ret->plt0_pad_byte = 0;
748
749 return &ret->elf.root;
750 }
751
752 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
753 shortcuts to them in our hash table. */
754
755 static bfd_boolean
756 create_got_section (bfd *dynobj, struct bfd_link_info *info)
757 {
758 struct elf_i386_link_hash_table *htab;
759
760 if (! _bfd_elf_create_got_section (dynobj, info))
761 return FALSE;
762
763 htab = elf_i386_hash_table (info);
764 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
765 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
766 if (!htab->sgot || !htab->sgotplt)
767 abort ();
768
769 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
770 (SEC_ALLOC | SEC_LOAD
771 | SEC_HAS_CONTENTS
772 | SEC_IN_MEMORY
773 | SEC_LINKER_CREATED
774 | SEC_READONLY));
775 if (htab->srelgot == NULL
776 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
777 return FALSE;
778 return TRUE;
779 }
780
781 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
782 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
783 hash table. */
784
785 static bfd_boolean
786 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
787 {
788 struct elf_i386_link_hash_table *htab;
789
790 htab = elf_i386_hash_table (info);
791 if (!htab->sgot && !create_got_section (dynobj, info))
792 return FALSE;
793
794 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
795 return FALSE;
796
797 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
798 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
799 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
800 if (!info->shared)
801 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
802
803 if (!htab->splt || !htab->srelplt || !htab->sdynbss
804 || (!info->shared && !htab->srelbss))
805 abort ();
806
807 if (htab->is_vxworks
808 && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
809 return FALSE;
810
811 return TRUE;
812 }
813
814 /* Copy the extra info we tack onto an elf_link_hash_entry. */
815
816 static void
817 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
818 struct elf_link_hash_entry *dir,
819 struct elf_link_hash_entry *ind)
820 {
821 struct elf_i386_link_hash_entry *edir, *eind;
822
823 edir = (struct elf_i386_link_hash_entry *) dir;
824 eind = (struct elf_i386_link_hash_entry *) ind;
825
826 if (eind->dyn_relocs != NULL)
827 {
828 if (edir->dyn_relocs != NULL)
829 {
830 struct elf_i386_dyn_relocs **pp;
831 struct elf_i386_dyn_relocs *p;
832
833 /* Add reloc counts against the indirect sym to the direct sym
834 list. Merge any entries against the same section. */
835 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
836 {
837 struct elf_i386_dyn_relocs *q;
838
839 for (q = edir->dyn_relocs; q != NULL; q = q->next)
840 if (q->sec == p->sec)
841 {
842 q->pc_count += p->pc_count;
843 q->count += p->count;
844 *pp = p->next;
845 break;
846 }
847 if (q == NULL)
848 pp = &p->next;
849 }
850 *pp = edir->dyn_relocs;
851 }
852
853 edir->dyn_relocs = eind->dyn_relocs;
854 eind->dyn_relocs = NULL;
855 }
856
857 if (ind->root.type == bfd_link_hash_indirect
858 && dir->got.refcount <= 0)
859 {
860 edir->tls_type = eind->tls_type;
861 eind->tls_type = GOT_UNKNOWN;
862 }
863
864 if (ELIMINATE_COPY_RELOCS
865 && ind->root.type != bfd_link_hash_indirect
866 && dir->dynamic_adjusted)
867 {
868 /* If called to transfer flags for a weakdef during processing
869 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
870 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
871 dir->ref_dynamic |= ind->ref_dynamic;
872 dir->ref_regular |= ind->ref_regular;
873 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
874 dir->needs_plt |= ind->needs_plt;
875 dir->pointer_equality_needed |= ind->pointer_equality_needed;
876 }
877 else
878 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
879 }
880
881 static int
882 elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
883 {
884 if (info->shared)
885 return r_type;
886
887 switch (r_type)
888 {
889 case R_386_TLS_GD:
890 case R_386_TLS_GOTDESC:
891 case R_386_TLS_DESC_CALL:
892 case R_386_TLS_IE_32:
893 if (is_local)
894 return R_386_TLS_LE_32;
895 return R_386_TLS_IE_32;
896 case R_386_TLS_IE:
897 case R_386_TLS_GOTIE:
898 if (is_local)
899 return R_386_TLS_LE_32;
900 return r_type;
901 case R_386_TLS_LDM:
902 return R_386_TLS_LE_32;
903 }
904
905 return r_type;
906 }
907
908 /* Look through the relocs for a section during the first phase, and
909 calculate needed space in the global offset table, procedure linkage
910 table, and dynamic reloc sections. */
911
912 static bfd_boolean
913 elf_i386_check_relocs (bfd *abfd,
914 struct bfd_link_info *info,
915 asection *sec,
916 const Elf_Internal_Rela *relocs)
917 {
918 struct elf_i386_link_hash_table *htab;
919 Elf_Internal_Shdr *symtab_hdr;
920 struct elf_link_hash_entry **sym_hashes;
921 const Elf_Internal_Rela *rel;
922 const Elf_Internal_Rela *rel_end;
923 asection *sreloc;
924
925 if (info->relocatable)
926 return TRUE;
927
928 htab = elf_i386_hash_table (info);
929 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
930 sym_hashes = elf_sym_hashes (abfd);
931
932 sreloc = NULL;
933
934 rel_end = relocs + sec->reloc_count;
935 for (rel = relocs; rel < rel_end; rel++)
936 {
937 unsigned int r_type;
938 unsigned long r_symndx;
939 struct elf_link_hash_entry *h;
940
941 r_symndx = ELF32_R_SYM (rel->r_info);
942 r_type = ELF32_R_TYPE (rel->r_info);
943
944 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
945 {
946 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
947 abfd,
948 r_symndx);
949 return FALSE;
950 }
951
952 if (r_symndx < symtab_hdr->sh_info)
953 h = NULL;
954 else
955 {
956 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
957 while (h->root.type == bfd_link_hash_indirect
958 || h->root.type == bfd_link_hash_warning)
959 h = (struct elf_link_hash_entry *) h->root.u.i.link;
960 }
961
962 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
963
964 switch (r_type)
965 {
966 case R_386_TLS_LDM:
967 htab->tls_ldm_got.refcount += 1;
968 goto create_got;
969
970 case R_386_PLT32:
971 /* This symbol requires a procedure linkage table entry. We
972 actually build the entry in adjust_dynamic_symbol,
973 because this might be a case of linking PIC code which is
974 never referenced by a dynamic object, in which case we
975 don't need to generate a procedure linkage table entry
976 after all. */
977
978 /* If this is a local symbol, we resolve it directly without
979 creating a procedure linkage table entry. */
980 if (h == NULL)
981 continue;
982
983 h->needs_plt = 1;
984 h->plt.refcount += 1;
985 break;
986
987 case R_386_TLS_IE_32:
988 case R_386_TLS_IE:
989 case R_386_TLS_GOTIE:
990 if (info->shared)
991 info->flags |= DF_STATIC_TLS;
992 /* Fall through */
993
994 case R_386_GOT32:
995 case R_386_TLS_GD:
996 case R_386_TLS_GOTDESC:
997 case R_386_TLS_DESC_CALL:
998 /* This symbol requires a global offset table entry. */
999 {
1000 int tls_type, old_tls_type;
1001
1002 switch (r_type)
1003 {
1004 default:
1005 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1006 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1007 case R_386_TLS_GOTDESC:
1008 case R_386_TLS_DESC_CALL:
1009 tls_type = GOT_TLS_GDESC; break;
1010 case R_386_TLS_IE_32:
1011 if (ELF32_R_TYPE (rel->r_info) == r_type)
1012 tls_type = GOT_TLS_IE_NEG;
1013 else
1014 /* If this is a GD->IE transition, we may use either of
1015 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1016 tls_type = GOT_TLS_IE;
1017 break;
1018 case R_386_TLS_IE:
1019 case R_386_TLS_GOTIE:
1020 tls_type = GOT_TLS_IE_POS; break;
1021 }
1022
1023 if (h != NULL)
1024 {
1025 h->got.refcount += 1;
1026 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1027 }
1028 else
1029 {
1030 bfd_signed_vma *local_got_refcounts;
1031
1032 /* This is a global offset table entry for a local symbol. */
1033 local_got_refcounts = elf_local_got_refcounts (abfd);
1034 if (local_got_refcounts == NULL)
1035 {
1036 bfd_size_type size;
1037
1038 size = symtab_hdr->sh_info;
1039 size *= (sizeof (bfd_signed_vma)
1040 + sizeof (bfd_vma) + sizeof(char));
1041 local_got_refcounts = bfd_zalloc (abfd, size);
1042 if (local_got_refcounts == NULL)
1043 return FALSE;
1044 elf_local_got_refcounts (abfd) = local_got_refcounts;
1045 elf_i386_local_tlsdesc_gotent (abfd)
1046 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1047 elf_i386_local_got_tls_type (abfd)
1048 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1049 }
1050 local_got_refcounts[r_symndx] += 1;
1051 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1052 }
1053
1054 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1055 tls_type |= old_tls_type;
1056 /* If a TLS symbol is accessed using IE at least once,
1057 there is no point to use dynamic model for it. */
1058 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1059 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1060 || (tls_type & GOT_TLS_IE) == 0))
1061 {
1062 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1063 tls_type = old_tls_type;
1064 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1065 && GOT_TLS_GD_ANY_P (tls_type))
1066 tls_type |= old_tls_type;
1067 else
1068 {
1069 (*_bfd_error_handler)
1070 (_("%B: `%s' accessed both as normal and "
1071 "thread local symbol"),
1072 abfd,
1073 h ? h->root.root.string : "<local>");
1074 return FALSE;
1075 }
1076 }
1077
1078 if (old_tls_type != tls_type)
1079 {
1080 if (h != NULL)
1081 elf_i386_hash_entry (h)->tls_type = tls_type;
1082 else
1083 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1084 }
1085 }
1086 /* Fall through */
1087
1088 case R_386_GOTOFF:
1089 case R_386_GOTPC:
1090 create_got:
1091 if (htab->sgot == NULL)
1092 {
1093 if (htab->elf.dynobj == NULL)
1094 htab->elf.dynobj = abfd;
1095 if (!create_got_section (htab->elf.dynobj, info))
1096 return FALSE;
1097 }
1098 if (r_type != R_386_TLS_IE)
1099 break;
1100 /* Fall through */
1101
1102 case R_386_TLS_LE_32:
1103 case R_386_TLS_LE:
1104 if (!info->shared)
1105 break;
1106 info->flags |= DF_STATIC_TLS;
1107 /* Fall through */
1108
1109 case R_386_32:
1110 case R_386_PC32:
1111 if (h != NULL && !info->shared)
1112 {
1113 /* If this reloc is in a read-only section, we might
1114 need a copy reloc. We can't check reliably at this
1115 stage whether the section is read-only, as input
1116 sections have not yet been mapped to output sections.
1117 Tentatively set the flag for now, and correct in
1118 adjust_dynamic_symbol. */
1119 h->non_got_ref = 1;
1120
1121 /* We may need a .plt entry if the function this reloc
1122 refers to is in a shared lib. */
1123 h->plt.refcount += 1;
1124 if (r_type != R_386_PC32)
1125 h->pointer_equality_needed = 1;
1126 }
1127
1128 /* If we are creating a shared library, and this is a reloc
1129 against a global symbol, or a non PC relative reloc
1130 against a local symbol, then we need to copy the reloc
1131 into the shared library. However, if we are linking with
1132 -Bsymbolic, we do not need to copy a reloc against a
1133 global symbol which is defined in an object we are
1134 including in the link (i.e., DEF_REGULAR is set). At
1135 this point we have not seen all the input files, so it is
1136 possible that DEF_REGULAR is not set now but will be set
1137 later (it is never cleared). In case of a weak definition,
1138 DEF_REGULAR may be cleared later by a strong definition in
1139 a shared library. We account for that possibility below by
1140 storing information in the relocs_copied field of the hash
1141 table entry. A similar situation occurs when creating
1142 shared libraries and symbol visibility changes render the
1143 symbol local.
1144
1145 If on the other hand, we are creating an executable, we
1146 may need to keep relocations for symbols satisfied by a
1147 dynamic library if we manage to avoid copy relocs for the
1148 symbol. */
1149 if ((info->shared
1150 && (sec->flags & SEC_ALLOC) != 0
1151 && (r_type != R_386_PC32
1152 || (h != NULL
1153 && (! SYMBOLIC_BIND (info, h)
1154 || h->root.type == bfd_link_hash_defweak
1155 || !h->def_regular))))
1156 || (ELIMINATE_COPY_RELOCS
1157 && !info->shared
1158 && (sec->flags & SEC_ALLOC) != 0
1159 && h != NULL
1160 && (h->root.type == bfd_link_hash_defweak
1161 || !h->def_regular)))
1162 {
1163 struct elf_i386_dyn_relocs *p;
1164 struct elf_i386_dyn_relocs **head;
1165
1166 /* We must copy these reloc types into the output file.
1167 Create a reloc section in dynobj and make room for
1168 this reloc. */
1169 if (sreloc == NULL)
1170 {
1171 const char *name;
1172 bfd *dynobj;
1173 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1174 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1175
1176 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1177 if (name == NULL)
1178 return FALSE;
1179
1180 if (! CONST_STRNEQ (name, ".rel")
1181 || strcmp (bfd_get_section_name (abfd, sec),
1182 name + 4) != 0)
1183 {
1184 (*_bfd_error_handler)
1185 (_("%B: bad relocation section name `%s\'"),
1186 abfd, name);
1187 }
1188
1189 if (htab->elf.dynobj == NULL)
1190 htab->elf.dynobj = abfd;
1191
1192 dynobj = htab->elf.dynobj;
1193 sreloc = bfd_get_section_by_name (dynobj, name);
1194 if (sreloc == NULL)
1195 {
1196 flagword flags;
1197
1198 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1199 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1200 if ((sec->flags & SEC_ALLOC) != 0)
1201 flags |= SEC_ALLOC | SEC_LOAD;
1202 sreloc = bfd_make_section_with_flags (dynobj,
1203 name,
1204 flags);
1205 if (sreloc == NULL
1206 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1207 return FALSE;
1208 }
1209 elf_section_data (sec)->sreloc = sreloc;
1210 }
1211
1212 /* If this is a global symbol, we count the number of
1213 relocations we need for this symbol. */
1214 if (h != NULL)
1215 {
1216 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1217 }
1218 else
1219 {
1220 void **vpp;
1221 /* Track dynamic relocs needed for local syms too.
1222 We really need local syms available to do this
1223 easily. Oh well. */
1224
1225 asection *s;
1226 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1227 sec, r_symndx);
1228 if (s == NULL)
1229 return FALSE;
1230
1231 vpp = &elf_section_data (s)->local_dynrel;
1232 head = (struct elf_i386_dyn_relocs **)vpp;
1233 }
1234
1235 p = *head;
1236 if (p == NULL || p->sec != sec)
1237 {
1238 bfd_size_type amt = sizeof *p;
1239 p = bfd_alloc (htab->elf.dynobj, amt);
1240 if (p == NULL)
1241 return FALSE;
1242 p->next = *head;
1243 *head = p;
1244 p->sec = sec;
1245 p->count = 0;
1246 p->pc_count = 0;
1247 }
1248
1249 p->count += 1;
1250 if (r_type == R_386_PC32)
1251 p->pc_count += 1;
1252 }
1253 break;
1254
1255 /* This relocation describes the C++ object vtable hierarchy.
1256 Reconstruct it for later use during GC. */
1257 case R_386_GNU_VTINHERIT:
1258 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1259 return FALSE;
1260 break;
1261
1262 /* This relocation describes which C++ vtable entries are actually
1263 used. Record for later use during GC. */
1264 case R_386_GNU_VTENTRY:
1265 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1266 return FALSE;
1267 break;
1268
1269 default:
1270 break;
1271 }
1272 }
1273
1274 return TRUE;
1275 }
1276
1277 /* Return the section that should be marked against GC for a given
1278 relocation. */
1279
1280 static asection *
1281 elf_i386_gc_mark_hook (asection *sec,
1282 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1283 Elf_Internal_Rela *rel,
1284 struct elf_link_hash_entry *h,
1285 Elf_Internal_Sym *sym)
1286 {
1287 if (h != NULL)
1288 {
1289 switch (ELF32_R_TYPE (rel->r_info))
1290 {
1291 case R_386_GNU_VTINHERIT:
1292 case R_386_GNU_VTENTRY:
1293 break;
1294
1295 default:
1296 switch (h->root.type)
1297 {
1298 case bfd_link_hash_defined:
1299 case bfd_link_hash_defweak:
1300 return h->root.u.def.section;
1301
1302 case bfd_link_hash_common:
1303 return h->root.u.c.p->section;
1304
1305 default:
1306 break;
1307 }
1308 }
1309 }
1310 else
1311 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1312
1313 return NULL;
1314 }
1315
1316 /* Update the got entry reference counts for the section being removed. */
1317
1318 static bfd_boolean
1319 elf_i386_gc_sweep_hook (bfd *abfd,
1320 struct bfd_link_info *info,
1321 asection *sec,
1322 const Elf_Internal_Rela *relocs)
1323 {
1324 Elf_Internal_Shdr *symtab_hdr;
1325 struct elf_link_hash_entry **sym_hashes;
1326 bfd_signed_vma *local_got_refcounts;
1327 const Elf_Internal_Rela *rel, *relend;
1328
1329 elf_section_data (sec)->local_dynrel = NULL;
1330
1331 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1332 sym_hashes = elf_sym_hashes (abfd);
1333 local_got_refcounts = elf_local_got_refcounts (abfd);
1334
1335 relend = relocs + sec->reloc_count;
1336 for (rel = relocs; rel < relend; rel++)
1337 {
1338 unsigned long r_symndx;
1339 unsigned int r_type;
1340 struct elf_link_hash_entry *h = NULL;
1341
1342 r_symndx = ELF32_R_SYM (rel->r_info);
1343 if (r_symndx >= symtab_hdr->sh_info)
1344 {
1345 struct elf_i386_link_hash_entry *eh;
1346 struct elf_i386_dyn_relocs **pp;
1347 struct elf_i386_dyn_relocs *p;
1348
1349 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1350 while (h->root.type == bfd_link_hash_indirect
1351 || h->root.type == bfd_link_hash_warning)
1352 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1353 eh = (struct elf_i386_link_hash_entry *) h;
1354
1355 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1356 if (p->sec == sec)
1357 {
1358 /* Everything must go for SEC. */
1359 *pp = p->next;
1360 break;
1361 }
1362 }
1363
1364 r_type = ELF32_R_TYPE (rel->r_info);
1365 r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1366 switch (r_type)
1367 {
1368 case R_386_TLS_LDM:
1369 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1370 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1371 break;
1372
1373 case R_386_TLS_GD:
1374 case R_386_TLS_GOTDESC:
1375 case R_386_TLS_DESC_CALL:
1376 case R_386_TLS_IE_32:
1377 case R_386_TLS_IE:
1378 case R_386_TLS_GOTIE:
1379 case R_386_GOT32:
1380 if (h != NULL)
1381 {
1382 if (h->got.refcount > 0)
1383 h->got.refcount -= 1;
1384 }
1385 else if (local_got_refcounts != NULL)
1386 {
1387 if (local_got_refcounts[r_symndx] > 0)
1388 local_got_refcounts[r_symndx] -= 1;
1389 }
1390 break;
1391
1392 case R_386_32:
1393 case R_386_PC32:
1394 if (info->shared)
1395 break;
1396 /* Fall through */
1397
1398 case R_386_PLT32:
1399 if (h != NULL)
1400 {
1401 if (h->plt.refcount > 0)
1402 h->plt.refcount -= 1;
1403 }
1404 break;
1405
1406 default:
1407 break;
1408 }
1409 }
1410
1411 return TRUE;
1412 }
1413
1414 /* Adjust a symbol defined by a dynamic object and referenced by a
1415 regular object. The current definition is in some section of the
1416 dynamic object, but we're not including those sections. We have to
1417 change the definition to something the rest of the link can
1418 understand. */
1419
1420 static bfd_boolean
1421 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1422 struct elf_link_hash_entry *h)
1423 {
1424 struct elf_i386_link_hash_table *htab;
1425 asection *s;
1426 unsigned int power_of_two;
1427
1428 /* If this is a function, put it in the procedure linkage table. We
1429 will fill in the contents of the procedure linkage table later,
1430 when we know the address of the .got section. */
1431 if (h->type == STT_FUNC
1432 || h->needs_plt)
1433 {
1434 if (h->plt.refcount <= 0
1435 || SYMBOL_CALLS_LOCAL (info, h)
1436 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1437 && h->root.type == bfd_link_hash_undefweak))
1438 {
1439 /* This case can occur if we saw a PLT32 reloc in an input
1440 file, but the symbol was never referred to by a dynamic
1441 object, or if all references were garbage collected. In
1442 such a case, we don't actually need to build a procedure
1443 linkage table, and we can just do a PC32 reloc instead. */
1444 h->plt.offset = (bfd_vma) -1;
1445 h->needs_plt = 0;
1446 }
1447
1448 return TRUE;
1449 }
1450 else
1451 /* It's possible that we incorrectly decided a .plt reloc was
1452 needed for an R_386_PC32 reloc to a non-function sym in
1453 check_relocs. We can't decide accurately between function and
1454 non-function syms in check-relocs; Objects loaded later in
1455 the link may change h->type. So fix it now. */
1456 h->plt.offset = (bfd_vma) -1;
1457
1458 /* If this is a weak symbol, and there is a real definition, the
1459 processor independent code will have arranged for us to see the
1460 real definition first, and we can just use the same value. */
1461 if (h->u.weakdef != NULL)
1462 {
1463 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1464 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1465 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1466 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1467 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1468 h->non_got_ref = h->u.weakdef->non_got_ref;
1469 return TRUE;
1470 }
1471
1472 /* This is a reference to a symbol defined by a dynamic object which
1473 is not a function. */
1474
1475 /* If we are creating a shared library, we must presume that the
1476 only references to the symbol are via the global offset table.
1477 For such cases we need not do anything here; the relocations will
1478 be handled correctly by relocate_section. */
1479 if (info->shared)
1480 return TRUE;
1481
1482 /* If there are no references to this symbol that do not use the
1483 GOT, we don't need to generate a copy reloc. */
1484 if (!h->non_got_ref)
1485 return TRUE;
1486
1487 /* If -z nocopyreloc was given, we won't generate them either. */
1488 if (info->nocopyreloc)
1489 {
1490 h->non_got_ref = 0;
1491 return TRUE;
1492 }
1493
1494 htab = elf_i386_hash_table (info);
1495
1496 /* If there aren't any dynamic relocs in read-only sections, then
1497 we can keep the dynamic relocs and avoid the copy reloc. This
1498 doesn't work on VxWorks, where we can not have dynamic relocations
1499 (other than copy and jump slot relocations) in an executable. */
1500 if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
1501 {
1502 struct elf_i386_link_hash_entry * eh;
1503 struct elf_i386_dyn_relocs *p;
1504
1505 eh = (struct elf_i386_link_hash_entry *) h;
1506 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1507 {
1508 s = p->sec->output_section;
1509 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1510 break;
1511 }
1512
1513 if (p == NULL)
1514 {
1515 h->non_got_ref = 0;
1516 return TRUE;
1517 }
1518 }
1519
1520 if (h->size == 0)
1521 {
1522 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1523 h->root.root.string);
1524 return TRUE;
1525 }
1526
1527 /* We must allocate the symbol in our .dynbss section, which will
1528 become part of the .bss section of the executable. There will be
1529 an entry for this symbol in the .dynsym section. The dynamic
1530 object will contain position independent code, so all references
1531 from the dynamic object to this symbol will go through the global
1532 offset table. The dynamic linker will use the .dynsym entry to
1533 determine the address it must put in the global offset table, so
1534 both the dynamic object and the regular object will refer to the
1535 same memory location for the variable. */
1536
1537 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1538 copy the initial value out of the dynamic object and into the
1539 runtime process image. */
1540 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1541 {
1542 htab->srelbss->size += sizeof (Elf32_External_Rel);
1543 h->needs_copy = 1;
1544 }
1545
1546 /* We need to figure out the alignment required for this symbol. I
1547 have no idea how ELF linkers handle this. */
1548 power_of_two = bfd_log2 (h->size);
1549 if (power_of_two > 3)
1550 power_of_two = 3;
1551
1552 /* Apply the required alignment. */
1553 s = htab->sdynbss;
1554 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1555 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1556 {
1557 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1558 return FALSE;
1559 }
1560
1561 /* Define the symbol as being at this point in the section. */
1562 h->root.u.def.section = s;
1563 h->root.u.def.value = s->size;
1564
1565 /* Increment the section size to make room for the symbol. */
1566 s->size += h->size;
1567
1568 return TRUE;
1569 }
1570
1571 /* Allocate space in .plt, .got and associated reloc sections for
1572 dynamic relocs. */
1573
1574 static bfd_boolean
1575 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1576 {
1577 struct bfd_link_info *info;
1578 struct elf_i386_link_hash_table *htab;
1579 struct elf_i386_link_hash_entry *eh;
1580 struct elf_i386_dyn_relocs *p;
1581
1582 if (h->root.type == bfd_link_hash_indirect)
1583 return TRUE;
1584
1585 if (h->root.type == bfd_link_hash_warning)
1586 /* When warning symbols are created, they **replace** the "real"
1587 entry in the hash table, thus we never get to see the real
1588 symbol in a hash traversal. So look at it now. */
1589 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1590
1591 info = (struct bfd_link_info *) inf;
1592 htab = elf_i386_hash_table (info);
1593
1594 if (htab->elf.dynamic_sections_created
1595 && h->plt.refcount > 0)
1596 {
1597 /* Make sure this symbol is output as a dynamic symbol.
1598 Undefined weak syms won't yet be marked as dynamic. */
1599 if (h->dynindx == -1
1600 && !h->forced_local)
1601 {
1602 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1603 return FALSE;
1604 }
1605
1606 if (info->shared
1607 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1608 {
1609 asection *s = htab->splt;
1610
1611 /* If this is the first .plt entry, make room for the special
1612 first entry. */
1613 if (s->size == 0)
1614 s->size += PLT_ENTRY_SIZE;
1615
1616 h->plt.offset = s->size;
1617
1618 /* If this symbol is not defined in a regular file, and we are
1619 not generating a shared library, then set the symbol to this
1620 location in the .plt. This is required to make function
1621 pointers compare as equal between the normal executable and
1622 the shared library. */
1623 if (! info->shared
1624 && !h->def_regular)
1625 {
1626 h->root.u.def.section = s;
1627 h->root.u.def.value = h->plt.offset;
1628 }
1629
1630 /* Make room for this entry. */
1631 s->size += PLT_ENTRY_SIZE;
1632
1633 /* We also need to make an entry in the .got.plt section, which
1634 will be placed in the .got section by the linker script. */
1635 htab->sgotplt->size += 4;
1636
1637 /* We also need to make an entry in the .rel.plt section. */
1638 htab->srelplt->size += sizeof (Elf32_External_Rel);
1639 htab->next_tls_desc_index++;
1640
1641 if (htab->is_vxworks && !info->shared)
1642 {
1643 /* VxWorks has a second set of relocations for each PLT entry
1644 in executables. They go in a separate relocation section,
1645 which is processed by the kernel loader. */
1646
1647 /* There are two relocations for the initial PLT entry: an
1648 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1649 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1650
1651 if (h->plt.offset == PLT_ENTRY_SIZE)
1652 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1653
1654 /* There are two extra relocations for each subsequent PLT entry:
1655 an R_386_32 relocation for the GOT entry, and an R_386_32
1656 relocation for the PLT entry. */
1657
1658 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1659 }
1660 }
1661 else
1662 {
1663 h->plt.offset = (bfd_vma) -1;
1664 h->needs_plt = 0;
1665 }
1666 }
1667 else
1668 {
1669 h->plt.offset = (bfd_vma) -1;
1670 h->needs_plt = 0;
1671 }
1672
1673 eh = (struct elf_i386_link_hash_entry *) h;
1674 eh->tlsdesc_got = (bfd_vma) -1;
1675
1676 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1677 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1678 if (h->got.refcount > 0
1679 && !info->shared
1680 && h->dynindx == -1
1681 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1682 h->got.offset = (bfd_vma) -1;
1683 else if (h->got.refcount > 0)
1684 {
1685 asection *s;
1686 bfd_boolean dyn;
1687 int tls_type = elf_i386_hash_entry(h)->tls_type;
1688
1689 /* Make sure this symbol is output as a dynamic symbol.
1690 Undefined weak syms won't yet be marked as dynamic. */
1691 if (h->dynindx == -1
1692 && !h->forced_local)
1693 {
1694 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1695 return FALSE;
1696 }
1697
1698 s = htab->sgot;
1699 if (GOT_TLS_GDESC_P (tls_type))
1700 {
1701 eh->tlsdesc_got = htab->sgotplt->size
1702 - elf_i386_compute_jump_table_size (htab);
1703 htab->sgotplt->size += 8;
1704 h->got.offset = (bfd_vma) -2;
1705 }
1706 if (! GOT_TLS_GDESC_P (tls_type)
1707 || GOT_TLS_GD_P (tls_type))
1708 {
1709 h->got.offset = s->size;
1710 s->size += 4;
1711 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1712 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1713 s->size += 4;
1714 }
1715 dyn = htab->elf.dynamic_sections_created;
1716 /* R_386_TLS_IE_32 needs one dynamic relocation,
1717 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1718 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1719 need two), R_386_TLS_GD needs one if local symbol and two if
1720 global. */
1721 if (tls_type == GOT_TLS_IE_BOTH)
1722 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1723 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1724 || (tls_type & GOT_TLS_IE))
1725 htab->srelgot->size += sizeof (Elf32_External_Rel);
1726 else if (GOT_TLS_GD_P (tls_type))
1727 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
1728 else if (! GOT_TLS_GDESC_P (tls_type)
1729 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1730 || h->root.type != bfd_link_hash_undefweak)
1731 && (info->shared
1732 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1733 htab->srelgot->size += sizeof (Elf32_External_Rel);
1734 if (GOT_TLS_GDESC_P (tls_type))
1735 htab->srelplt->size += sizeof (Elf32_External_Rel);
1736 }
1737 else
1738 h->got.offset = (bfd_vma) -1;
1739
1740 if (eh->dyn_relocs == NULL)
1741 return TRUE;
1742
1743 /* In the shared -Bsymbolic case, discard space allocated for
1744 dynamic pc-relative relocs against symbols which turn out to be
1745 defined in regular objects. For the normal shared case, discard
1746 space for pc-relative relocs that have become local due to symbol
1747 visibility changes. */
1748
1749 if (info->shared)
1750 {
1751 /* The only reloc that uses pc_count is R_386_PC32, which will
1752 appear on a call or on something like ".long foo - .". We
1753 want calls to protected symbols to resolve directly to the
1754 function rather than going via the plt. If people want
1755 function pointer comparisons to work as expected then they
1756 should avoid writing assembly like ".long foo - .". */
1757 if (SYMBOL_CALLS_LOCAL (info, h))
1758 {
1759 struct elf_i386_dyn_relocs **pp;
1760
1761 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1762 {
1763 p->count -= p->pc_count;
1764 p->pc_count = 0;
1765 if (p->count == 0)
1766 *pp = p->next;
1767 else
1768 pp = &p->next;
1769 }
1770 }
1771
1772 /* Also discard relocs on undefined weak syms with non-default
1773 visibility. */
1774 if (eh->dyn_relocs != NULL
1775 && h->root.type == bfd_link_hash_undefweak)
1776 {
1777 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1778 eh->dyn_relocs = NULL;
1779
1780 /* Make sure undefined weak symbols are output as a dynamic
1781 symbol in PIEs. */
1782 else if (h->dynindx == -1
1783 && !h->forced_local)
1784 {
1785 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1786 return FALSE;
1787 }
1788 }
1789 }
1790 else if (ELIMINATE_COPY_RELOCS)
1791 {
1792 /* For the non-shared case, discard space for relocs against
1793 symbols which turn out to need copy relocs or are not
1794 dynamic. */
1795
1796 if (!h->non_got_ref
1797 && ((h->def_dynamic
1798 && !h->def_regular)
1799 || (htab->elf.dynamic_sections_created
1800 && (h->root.type == bfd_link_hash_undefweak
1801 || h->root.type == bfd_link_hash_undefined))))
1802 {
1803 /* Make sure this symbol is output as a dynamic symbol.
1804 Undefined weak syms won't yet be marked as dynamic. */
1805 if (h->dynindx == -1
1806 && !h->forced_local)
1807 {
1808 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1809 return FALSE;
1810 }
1811
1812 /* If that succeeded, we know we'll be keeping all the
1813 relocs. */
1814 if (h->dynindx != -1)
1815 goto keep;
1816 }
1817
1818 eh->dyn_relocs = NULL;
1819
1820 keep: ;
1821 }
1822
1823 /* Finally, allocate space. */
1824 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1825 {
1826 asection *sreloc = elf_section_data (p->sec)->sreloc;
1827 sreloc->size += p->count * sizeof (Elf32_External_Rel);
1828 }
1829
1830 return TRUE;
1831 }
1832
1833 /* Find any dynamic relocs that apply to read-only sections. */
1834
1835 static bfd_boolean
1836 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1837 {
1838 struct elf_i386_link_hash_entry *eh;
1839 struct elf_i386_dyn_relocs *p;
1840
1841 if (h->root.type == bfd_link_hash_warning)
1842 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1843
1844 eh = (struct elf_i386_link_hash_entry *) h;
1845 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1846 {
1847 asection *s = p->sec->output_section;
1848
1849 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1850 {
1851 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1852
1853 info->flags |= DF_TEXTREL;
1854
1855 /* Not an error, just cut short the traversal. */
1856 return FALSE;
1857 }
1858 }
1859 return TRUE;
1860 }
1861
1862 /* Set the sizes of the dynamic sections. */
1863
1864 static bfd_boolean
1865 elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1866 struct bfd_link_info *info)
1867 {
1868 struct elf_i386_link_hash_table *htab;
1869 bfd *dynobj;
1870 asection *s;
1871 bfd_boolean relocs;
1872 bfd *ibfd;
1873
1874 htab = elf_i386_hash_table (info);
1875 dynobj = htab->elf.dynobj;
1876 if (dynobj == NULL)
1877 abort ();
1878
1879 if (htab->elf.dynamic_sections_created)
1880 {
1881 /* Set the contents of the .interp section to the interpreter. */
1882 if (info->executable)
1883 {
1884 s = bfd_get_section_by_name (dynobj, ".interp");
1885 if (s == NULL)
1886 abort ();
1887 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1888 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1889 }
1890 }
1891
1892 /* Set up .got offsets for local syms, and space for local dynamic
1893 relocs. */
1894 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1895 {
1896 bfd_signed_vma *local_got;
1897 bfd_signed_vma *end_local_got;
1898 char *local_tls_type;
1899 bfd_vma *local_tlsdesc_gotent;
1900 bfd_size_type locsymcount;
1901 Elf_Internal_Shdr *symtab_hdr;
1902 asection *srel;
1903
1904 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1905 continue;
1906
1907 for (s = ibfd->sections; s != NULL; s = s->next)
1908 {
1909 struct elf_i386_dyn_relocs *p;
1910
1911 for (p = ((struct elf_i386_dyn_relocs *)
1912 elf_section_data (s)->local_dynrel);
1913 p != NULL;
1914 p = p->next)
1915 {
1916 if (!bfd_is_abs_section (p->sec)
1917 && bfd_is_abs_section (p->sec->output_section))
1918 {
1919 /* Input section has been discarded, either because
1920 it is a copy of a linkonce section or due to
1921 linker script /DISCARD/, so we'll be discarding
1922 the relocs too. */
1923 }
1924 else if (p->count != 0)
1925 {
1926 srel = elf_section_data (p->sec)->sreloc;
1927 srel->size += p->count * sizeof (Elf32_External_Rel);
1928 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1929 info->flags |= DF_TEXTREL;
1930 }
1931 }
1932 }
1933
1934 local_got = elf_local_got_refcounts (ibfd);
1935 if (!local_got)
1936 continue;
1937
1938 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1939 locsymcount = symtab_hdr->sh_info;
1940 end_local_got = local_got + locsymcount;
1941 local_tls_type = elf_i386_local_got_tls_type (ibfd);
1942 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
1943 s = htab->sgot;
1944 srel = htab->srelgot;
1945 for (; local_got < end_local_got;
1946 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1947 {
1948 *local_tlsdesc_gotent = (bfd_vma) -1;
1949 if (*local_got > 0)
1950 {
1951 if (GOT_TLS_GDESC_P (*local_tls_type))
1952 {
1953 *local_tlsdesc_gotent = htab->sgotplt->size
1954 - elf_i386_compute_jump_table_size (htab);
1955 htab->sgotplt->size += 8;
1956 *local_got = (bfd_vma) -2;
1957 }
1958 if (! GOT_TLS_GDESC_P (*local_tls_type)
1959 || GOT_TLS_GD_P (*local_tls_type))
1960 {
1961 *local_got = s->size;
1962 s->size += 4;
1963 if (GOT_TLS_GD_P (*local_tls_type)
1964 || *local_tls_type == GOT_TLS_IE_BOTH)
1965 s->size += 4;
1966 }
1967 if (info->shared
1968 || GOT_TLS_GD_ANY_P (*local_tls_type)
1969 || (*local_tls_type & GOT_TLS_IE))
1970 {
1971 if (*local_tls_type == GOT_TLS_IE_BOTH)
1972 srel->size += 2 * sizeof (Elf32_External_Rel);
1973 else if (GOT_TLS_GD_P (*local_tls_type)
1974 || ! GOT_TLS_GDESC_P (*local_tls_type))
1975 srel->size += sizeof (Elf32_External_Rel);
1976 if (GOT_TLS_GDESC_P (*local_tls_type))
1977 htab->srelplt->size += sizeof (Elf32_External_Rel);
1978 }
1979 }
1980 else
1981 *local_got = (bfd_vma) -1;
1982 }
1983 }
1984
1985 if (htab->tls_ldm_got.refcount > 0)
1986 {
1987 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1988 relocs. */
1989 htab->tls_ldm_got.offset = htab->sgot->size;
1990 htab->sgot->size += 8;
1991 htab->srelgot->size += sizeof (Elf32_External_Rel);
1992 }
1993 else
1994 htab->tls_ldm_got.offset = -1;
1995
1996 /* Allocate global sym .plt and .got entries, and space for global
1997 sym dynamic relocs. */
1998 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1999
2000 /* For every jump slot reserved in the sgotplt, reloc_count is
2001 incremented. However, when we reserve space for TLS descriptors,
2002 it's not incremented, so in order to compute the space reserved
2003 for them, it suffices to multiply the reloc count by the jump
2004 slot size. */
2005 if (htab->srelplt)
2006 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2007
2008 /* We now have determined the sizes of the various dynamic sections.
2009 Allocate memory for them. */
2010 relocs = FALSE;
2011 for (s = dynobj->sections; s != NULL; s = s->next)
2012 {
2013 bfd_boolean strip_section = TRUE;
2014
2015 if ((s->flags & SEC_LINKER_CREATED) == 0)
2016 continue;
2017
2018 if (s == htab->splt
2019 || s == htab->sgot
2020 || s == htab->sgotplt
2021 || s == htab->sdynbss)
2022 {
2023 /* Strip this section if we don't need it; see the
2024 comment below. */
2025 /* We'd like to strip these sections if they aren't needed, but if
2026 we've exported dynamic symbols from them we must leave them.
2027 It's too late to tell BFD to get rid of the symbols. */
2028
2029 if (htab->elf.hplt != NULL)
2030 strip_section = FALSE;
2031 }
2032 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2033 {
2034 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
2035 relocs = TRUE;
2036
2037 /* We use the reloc_count field as a counter if we need
2038 to copy relocs into the output file. */
2039 s->reloc_count = 0;
2040 }
2041 else
2042 {
2043 /* It's not one of our sections, so don't allocate space. */
2044 continue;
2045 }
2046
2047 if (s->size == 0)
2048 {
2049 /* If we don't need this section, strip it from the
2050 output file. This is mostly to handle .rel.bss and
2051 .rel.plt. We must create both sections in
2052 create_dynamic_sections, because they must be created
2053 before the linker maps input sections to output
2054 sections. The linker does that before
2055 adjust_dynamic_symbol is called, and it is that
2056 function which decides whether anything needs to go
2057 into these sections. */
2058 if (strip_section)
2059 s->flags |= SEC_EXCLUDE;
2060 continue;
2061 }
2062
2063 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2064 continue;
2065
2066 /* Allocate memory for the section contents. We use bfd_zalloc
2067 here in case unused entries are not reclaimed before the
2068 section's contents are written out. This should not happen,
2069 but this way if it does, we get a R_386_NONE reloc instead
2070 of garbage. */
2071 s->contents = bfd_zalloc (dynobj, s->size);
2072 if (s->contents == NULL)
2073 return FALSE;
2074 }
2075
2076 if (htab->elf.dynamic_sections_created)
2077 {
2078 /* Add some entries to the .dynamic section. We fill in the
2079 values later, in elf_i386_finish_dynamic_sections, but we
2080 must add the entries now so that we get the correct size for
2081 the .dynamic section. The DT_DEBUG entry is filled in by the
2082 dynamic linker and used by the debugger. */
2083 #define add_dynamic_entry(TAG, VAL) \
2084 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2085
2086 if (info->executable)
2087 {
2088 if (!add_dynamic_entry (DT_DEBUG, 0))
2089 return FALSE;
2090 }
2091
2092 if (htab->splt->size != 0)
2093 {
2094 if (!add_dynamic_entry (DT_PLTGOT, 0)
2095 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2096 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2097 || !add_dynamic_entry (DT_JMPREL, 0))
2098 return FALSE;
2099 }
2100
2101 if (relocs)
2102 {
2103 if (!add_dynamic_entry (DT_REL, 0)
2104 || !add_dynamic_entry (DT_RELSZ, 0)
2105 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2106 return FALSE;
2107
2108 /* If any dynamic relocs apply to a read-only section,
2109 then we need a DT_TEXTREL entry. */
2110 if ((info->flags & DF_TEXTREL) == 0)
2111 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2112 (PTR) info);
2113
2114 if ((info->flags & DF_TEXTREL) != 0)
2115 {
2116 if (!add_dynamic_entry (DT_TEXTREL, 0))
2117 return FALSE;
2118 }
2119 }
2120 }
2121 #undef add_dynamic_entry
2122
2123 return TRUE;
2124 }
2125
2126 static bfd_boolean
2127 elf_i386_always_size_sections (bfd *output_bfd,
2128 struct bfd_link_info *info)
2129 {
2130 asection *tls_sec = elf_hash_table (info)->tls_sec;
2131
2132 if (tls_sec)
2133 {
2134 struct elf_link_hash_entry *tlsbase;
2135
2136 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2137 "_TLS_MODULE_BASE_",
2138 FALSE, FALSE, FALSE);
2139
2140 if (tlsbase && tlsbase->type == STT_TLS)
2141 {
2142 struct bfd_link_hash_entry *bh = NULL;
2143 const struct elf_backend_data *bed
2144 = get_elf_backend_data (output_bfd);
2145
2146 if (!(_bfd_generic_link_add_one_symbol
2147 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2148 tls_sec, 0, NULL, FALSE,
2149 bed->collect, &bh)))
2150 return FALSE;
2151 tlsbase = (struct elf_link_hash_entry *)bh;
2152 tlsbase->def_regular = 1;
2153 tlsbase->other = STV_HIDDEN;
2154 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2155 }
2156 }
2157
2158 return TRUE;
2159 }
2160
2161 /* Set the correct type for an x86 ELF section. We do this by the
2162 section name, which is a hack, but ought to work. */
2163
2164 static bfd_boolean
2165 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2166 Elf_Internal_Shdr *hdr,
2167 asection *sec)
2168 {
2169 register const char *name;
2170
2171 name = bfd_get_section_name (abfd, sec);
2172
2173 /* This is an ugly, but unfortunately necessary hack that is
2174 needed when producing EFI binaries on x86. It tells
2175 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2176 containing ELF relocation info. We need this hack in order to
2177 be able to generate ELF binaries that can be translated into
2178 EFI applications (which are essentially COFF objects). Those
2179 files contain a COFF ".reloc" section inside an ELFNN object,
2180 which would normally cause BFD to segfault because it would
2181 attempt to interpret this section as containing relocation
2182 entries for section "oc". With this hack enabled, ".reloc"
2183 will be treated as a normal data section, which will avoid the
2184 segfault. However, you won't be able to create an ELFNN binary
2185 with a section named "oc" that needs relocations, but that's
2186 the kind of ugly side-effects you get when detecting section
2187 types based on their names... In practice, this limitation is
2188 unlikely to bite. */
2189 if (strcmp (name, ".reloc") == 0)
2190 hdr->sh_type = SHT_PROGBITS;
2191
2192 return TRUE;
2193 }
2194
2195 /* Return the base VMA address which should be subtracted from real addresses
2196 when resolving @dtpoff relocation.
2197 This is PT_TLS segment p_vaddr. */
2198
2199 static bfd_vma
2200 dtpoff_base (struct bfd_link_info *info)
2201 {
2202 /* If tls_sec is NULL, we should have signalled an error already. */
2203 if (elf_hash_table (info)->tls_sec == NULL)
2204 return 0;
2205 return elf_hash_table (info)->tls_sec->vma;
2206 }
2207
2208 /* Return the relocation value for @tpoff relocation
2209 if STT_TLS virtual address is ADDRESS. */
2210
2211 static bfd_vma
2212 tpoff (struct bfd_link_info *info, bfd_vma address)
2213 {
2214 struct elf_link_hash_table *htab = elf_hash_table (info);
2215
2216 /* If tls_sec is NULL, we should have signalled an error already. */
2217 if (htab->tls_sec == NULL)
2218 return 0;
2219 return htab->tls_size + htab->tls_sec->vma - address;
2220 }
2221
2222 /* Relocate an i386 ELF section. */
2223
2224 static bfd_boolean
2225 elf_i386_relocate_section (bfd *output_bfd,
2226 struct bfd_link_info *info,
2227 bfd *input_bfd,
2228 asection *input_section,
2229 bfd_byte *contents,
2230 Elf_Internal_Rela *relocs,
2231 Elf_Internal_Sym *local_syms,
2232 asection **local_sections)
2233 {
2234 struct elf_i386_link_hash_table *htab;
2235 Elf_Internal_Shdr *symtab_hdr;
2236 struct elf_link_hash_entry **sym_hashes;
2237 bfd_vma *local_got_offsets;
2238 bfd_vma *local_tlsdesc_gotents;
2239 Elf_Internal_Rela *rel;
2240 Elf_Internal_Rela *relend;
2241
2242 htab = elf_i386_hash_table (info);
2243 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2244 sym_hashes = elf_sym_hashes (input_bfd);
2245 local_got_offsets = elf_local_got_offsets (input_bfd);
2246 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
2247
2248 rel = relocs;
2249 relend = relocs + input_section->reloc_count;
2250 for (; rel < relend; rel++)
2251 {
2252 unsigned int r_type;
2253 reloc_howto_type *howto;
2254 unsigned long r_symndx;
2255 struct elf_link_hash_entry *h;
2256 Elf_Internal_Sym *sym;
2257 asection *sec;
2258 bfd_vma off, offplt;
2259 bfd_vma relocation;
2260 bfd_boolean unresolved_reloc;
2261 bfd_reloc_status_type r;
2262 unsigned int indx;
2263 int tls_type;
2264
2265 r_type = ELF32_R_TYPE (rel->r_info);
2266 if (r_type == R_386_GNU_VTINHERIT
2267 || r_type == R_386_GNU_VTENTRY)
2268 continue;
2269
2270 if ((indx = r_type) >= R_386_standard
2271 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2272 >= R_386_ext - R_386_standard)
2273 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2274 >= R_386_tls - R_386_ext))
2275 {
2276 (*_bfd_error_handler)
2277 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2278 input_bfd, input_section, r_type);
2279 bfd_set_error (bfd_error_bad_value);
2280 return FALSE;
2281 }
2282 howto = elf_howto_table + indx;
2283
2284 r_symndx = ELF32_R_SYM (rel->r_info);
2285
2286 if (info->relocatable)
2287 {
2288 bfd_vma val;
2289 bfd_byte *where;
2290
2291 /* This is a relocatable link. We don't have to change
2292 anything, unless the reloc is against a section symbol,
2293 in which case we have to adjust according to where the
2294 section symbol winds up in the output section. */
2295 if (r_symndx >= symtab_hdr->sh_info)
2296 continue;
2297
2298 sym = local_syms + r_symndx;
2299 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2300 continue;
2301
2302 sec = local_sections[r_symndx];
2303 val = sec->output_offset;
2304 if (val == 0)
2305 continue;
2306
2307 where = contents + rel->r_offset;
2308 switch (howto->size)
2309 {
2310 /* FIXME: overflow checks. */
2311 case 0:
2312 val += bfd_get_8 (input_bfd, where);
2313 bfd_put_8 (input_bfd, val, where);
2314 break;
2315 case 1:
2316 val += bfd_get_16 (input_bfd, where);
2317 bfd_put_16 (input_bfd, val, where);
2318 break;
2319 case 2:
2320 val += bfd_get_32 (input_bfd, where);
2321 bfd_put_32 (input_bfd, val, where);
2322 break;
2323 default:
2324 abort ();
2325 }
2326 continue;
2327 }
2328
2329 /* This is a final link. */
2330 h = NULL;
2331 sym = NULL;
2332 sec = NULL;
2333 unresolved_reloc = FALSE;
2334 if (r_symndx < symtab_hdr->sh_info)
2335 {
2336 sym = local_syms + r_symndx;
2337 sec = local_sections[r_symndx];
2338 relocation = (sec->output_section->vma
2339 + sec->output_offset
2340 + sym->st_value);
2341 if ((sec->flags & SEC_MERGE)
2342 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2343 {
2344 asection *msec;
2345 bfd_vma addend;
2346 bfd_byte *where = contents + rel->r_offset;
2347
2348 switch (howto->size)
2349 {
2350 case 0:
2351 addend = bfd_get_8 (input_bfd, where);
2352 if (howto->pc_relative)
2353 {
2354 addend = (addend ^ 0x80) - 0x80;
2355 addend += 1;
2356 }
2357 break;
2358 case 1:
2359 addend = bfd_get_16 (input_bfd, where);
2360 if (howto->pc_relative)
2361 {
2362 addend = (addend ^ 0x8000) - 0x8000;
2363 addend += 2;
2364 }
2365 break;
2366 case 2:
2367 addend = bfd_get_32 (input_bfd, where);
2368 if (howto->pc_relative)
2369 {
2370 addend = (addend ^ 0x80000000) - 0x80000000;
2371 addend += 4;
2372 }
2373 break;
2374 default:
2375 abort ();
2376 }
2377
2378 msec = sec;
2379 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2380 addend -= relocation;
2381 addend += msec->output_section->vma + msec->output_offset;
2382
2383 switch (howto->size)
2384 {
2385 case 0:
2386 /* FIXME: overflow checks. */
2387 if (howto->pc_relative)
2388 addend -= 1;
2389 bfd_put_8 (input_bfd, addend, where);
2390 break;
2391 case 1:
2392 if (howto->pc_relative)
2393 addend -= 2;
2394 bfd_put_16 (input_bfd, addend, where);
2395 break;
2396 case 2:
2397 if (howto->pc_relative)
2398 addend -= 4;
2399 bfd_put_32 (input_bfd, addend, where);
2400 break;
2401 }
2402 }
2403 }
2404 else
2405 {
2406 bfd_boolean warned;
2407
2408 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2409 r_symndx, symtab_hdr, sym_hashes,
2410 h, sec, relocation,
2411 unresolved_reloc, warned);
2412 }
2413
2414 if (r_symndx == 0)
2415 {
2416 /* r_symndx will be zero only for relocs against symbols from
2417 removed linkonce sections, or sections discarded by a linker
2418 script. For these relocs, we just want the section contents
2419 zeroed. Avoid any special processing in the switch below. */
2420 r_type = R_386_NONE;
2421
2422 relocation = 0;
2423 if (howto->pc_relative)
2424 relocation = (input_section->output_section->vma
2425 + input_section->output_offset
2426 + rel->r_offset);
2427 }
2428
2429 switch (r_type)
2430 {
2431 case R_386_GOT32:
2432 /* Relocation is to the entry for this symbol in the global
2433 offset table. */
2434 if (htab->sgot == NULL)
2435 abort ();
2436
2437 if (h != NULL)
2438 {
2439 bfd_boolean dyn;
2440
2441 off = h->got.offset;
2442 dyn = htab->elf.dynamic_sections_created;
2443 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2444 || (info->shared
2445 && SYMBOL_REFERENCES_LOCAL (info, h))
2446 || (ELF_ST_VISIBILITY (h->other)
2447 && h->root.type == bfd_link_hash_undefweak))
2448 {
2449 /* This is actually a static link, or it is a
2450 -Bsymbolic link and the symbol is defined
2451 locally, or the symbol was forced to be local
2452 because of a version file. We must initialize
2453 this entry in the global offset table. Since the
2454 offset must always be a multiple of 4, we use the
2455 least significant bit to record whether we have
2456 initialized it already.
2457
2458 When doing a dynamic link, we create a .rel.got
2459 relocation entry to initialize the value. This
2460 is done in the finish_dynamic_symbol routine. */
2461 if ((off & 1) != 0)
2462 off &= ~1;
2463 else
2464 {
2465 bfd_put_32 (output_bfd, relocation,
2466 htab->sgot->contents + off);
2467 h->got.offset |= 1;
2468 }
2469 }
2470 else
2471 unresolved_reloc = FALSE;
2472 }
2473 else
2474 {
2475 if (local_got_offsets == NULL)
2476 abort ();
2477
2478 off = local_got_offsets[r_symndx];
2479
2480 /* The offset must always be a multiple of 4. We use
2481 the least significant bit to record whether we have
2482 already generated the necessary reloc. */
2483 if ((off & 1) != 0)
2484 off &= ~1;
2485 else
2486 {
2487 bfd_put_32 (output_bfd, relocation,
2488 htab->sgot->contents + off);
2489
2490 if (info->shared)
2491 {
2492 asection *s;
2493 Elf_Internal_Rela outrel;
2494 bfd_byte *loc;
2495
2496 s = htab->srelgot;
2497 if (s == NULL)
2498 abort ();
2499
2500 outrel.r_offset = (htab->sgot->output_section->vma
2501 + htab->sgot->output_offset
2502 + off);
2503 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2504 loc = s->contents;
2505 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2506 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2507 }
2508
2509 local_got_offsets[r_symndx] |= 1;
2510 }
2511 }
2512
2513 if (off >= (bfd_vma) -2)
2514 abort ();
2515
2516 relocation = htab->sgot->output_section->vma
2517 + htab->sgot->output_offset + off
2518 - htab->sgotplt->output_section->vma
2519 - htab->sgotplt->output_offset;
2520 break;
2521
2522 case R_386_GOTOFF:
2523 /* Relocation is relative to the start of the global offset
2524 table. */
2525
2526 /* Check to make sure it isn't a protected function symbol
2527 for shared library since it may not be local when used
2528 as function address. */
2529 if (info->shared
2530 && !info->executable
2531 && h
2532 && h->def_regular
2533 && h->type == STT_FUNC
2534 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2535 {
2536 (*_bfd_error_handler)
2537 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2538 input_bfd, h->root.root.string);
2539 bfd_set_error (bfd_error_bad_value);
2540 return FALSE;
2541 }
2542
2543 /* Note that sgot is not involved in this
2544 calculation. We always want the start of .got.plt. If we
2545 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2546 permitted by the ABI, we might have to change this
2547 calculation. */
2548 relocation -= htab->sgotplt->output_section->vma
2549 + htab->sgotplt->output_offset;
2550 break;
2551
2552 case R_386_GOTPC:
2553 /* Use global offset table as symbol value. */
2554 relocation = htab->sgotplt->output_section->vma
2555 + htab->sgotplt->output_offset;
2556 unresolved_reloc = FALSE;
2557 break;
2558
2559 case R_386_PLT32:
2560 /* Relocation is to the entry for this symbol in the
2561 procedure linkage table. */
2562
2563 /* Resolve a PLT32 reloc against a local symbol directly,
2564 without using the procedure linkage table. */
2565 if (h == NULL)
2566 break;
2567
2568 if (h->plt.offset == (bfd_vma) -1
2569 || htab->splt == NULL)
2570 {
2571 /* We didn't make a PLT entry for this symbol. This
2572 happens when statically linking PIC code, or when
2573 using -Bsymbolic. */
2574 break;
2575 }
2576
2577 relocation = (htab->splt->output_section->vma
2578 + htab->splt->output_offset
2579 + h->plt.offset);
2580 unresolved_reloc = FALSE;
2581 break;
2582
2583 case R_386_32:
2584 case R_386_PC32:
2585 if ((input_section->flags & SEC_ALLOC) == 0)
2586 break;
2587
2588 if ((info->shared
2589 && (h == NULL
2590 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2591 || h->root.type != bfd_link_hash_undefweak)
2592 && (r_type != R_386_PC32
2593 || !SYMBOL_CALLS_LOCAL (info, h)))
2594 || (ELIMINATE_COPY_RELOCS
2595 && !info->shared
2596 && h != NULL
2597 && h->dynindx != -1
2598 && !h->non_got_ref
2599 && ((h->def_dynamic
2600 && !h->def_regular)
2601 || h->root.type == bfd_link_hash_undefweak
2602 || h->root.type == bfd_link_hash_undefined)))
2603 {
2604 Elf_Internal_Rela outrel;
2605 bfd_byte *loc;
2606 bfd_boolean skip, relocate;
2607 asection *sreloc;
2608
2609 /* When generating a shared object, these relocations
2610 are copied into the output file to be resolved at run
2611 time. */
2612
2613 skip = FALSE;
2614 relocate = FALSE;
2615
2616 outrel.r_offset =
2617 _bfd_elf_section_offset (output_bfd, info, input_section,
2618 rel->r_offset);
2619 if (outrel.r_offset == (bfd_vma) -1)
2620 skip = TRUE;
2621 else if (outrel.r_offset == (bfd_vma) -2)
2622 skip = TRUE, relocate = TRUE;
2623 outrel.r_offset += (input_section->output_section->vma
2624 + input_section->output_offset);
2625
2626 if (skip)
2627 memset (&outrel, 0, sizeof outrel);
2628 else if (h != NULL
2629 && h->dynindx != -1
2630 && (r_type == R_386_PC32
2631 || !info->shared
2632 || !SYMBOLIC_BIND (info, h)
2633 || !h->def_regular))
2634 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2635 else
2636 {
2637 /* This symbol is local, or marked to become local. */
2638 relocate = TRUE;
2639 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2640 }
2641
2642 sreloc = elf_section_data (input_section)->sreloc;
2643 if (sreloc == NULL)
2644 abort ();
2645
2646 loc = sreloc->contents;
2647 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2648 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2649
2650 /* If this reloc is against an external symbol, we do
2651 not want to fiddle with the addend. Otherwise, we
2652 need to include the symbol value so that it becomes
2653 an addend for the dynamic reloc. */
2654 if (! relocate)
2655 continue;
2656 }
2657 break;
2658
2659 case R_386_TLS_IE:
2660 if (info->shared)
2661 {
2662 Elf_Internal_Rela outrel;
2663 bfd_byte *loc;
2664 asection *sreloc;
2665
2666 outrel.r_offset = rel->r_offset
2667 + input_section->output_section->vma
2668 + input_section->output_offset;
2669 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2670 sreloc = elf_section_data (input_section)->sreloc;
2671 if (sreloc == NULL)
2672 abort ();
2673 loc = sreloc->contents;
2674 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2675 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2676 }
2677 /* Fall through */
2678
2679 case R_386_TLS_GD:
2680 case R_386_TLS_GOTDESC:
2681 case R_386_TLS_DESC_CALL:
2682 case R_386_TLS_IE_32:
2683 case R_386_TLS_GOTIE:
2684 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2685 tls_type = GOT_UNKNOWN;
2686 if (h == NULL && local_got_offsets)
2687 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2688 else if (h != NULL)
2689 {
2690 tls_type = elf_i386_hash_entry(h)->tls_type;
2691 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2692 r_type = R_386_TLS_LE_32;
2693 }
2694 if (tls_type == GOT_TLS_IE)
2695 tls_type = GOT_TLS_IE_NEG;
2696 if (r_type == R_386_TLS_GD
2697 || r_type == R_386_TLS_GOTDESC
2698 || r_type == R_386_TLS_DESC_CALL)
2699 {
2700 if (tls_type == GOT_TLS_IE_POS)
2701 r_type = R_386_TLS_GOTIE;
2702 else if (tls_type & GOT_TLS_IE)
2703 r_type = R_386_TLS_IE_32;
2704 }
2705
2706 if (r_type == R_386_TLS_LE_32)
2707 {
2708 BFD_ASSERT (! unresolved_reloc);
2709 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2710 {
2711 unsigned int val, type;
2712 bfd_vma roff;
2713
2714 /* GD->LE transition. */
2715 BFD_ASSERT (rel->r_offset >= 2);
2716 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2717 BFD_ASSERT (type == 0x8d || type == 0x04);
2718 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2719 BFD_ASSERT (bfd_get_8 (input_bfd,
2720 contents + rel->r_offset + 4)
2721 == 0xe8);
2722 BFD_ASSERT (rel + 1 < relend);
2723 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2724 roff = rel->r_offset + 5;
2725 val = bfd_get_8 (input_bfd,
2726 contents + rel->r_offset - 1);
2727 if (type == 0x04)
2728 {
2729 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2730 Change it into:
2731 movl %gs:0, %eax; subl $foo@tpoff, %eax
2732 (6 byte form of subl). */
2733 BFD_ASSERT (rel->r_offset >= 3);
2734 BFD_ASSERT (bfd_get_8 (input_bfd,
2735 contents + rel->r_offset - 3)
2736 == 0x8d);
2737 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2738 memcpy (contents + rel->r_offset - 3,
2739 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2740 }
2741 else
2742 {
2743 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2744 if (rel->r_offset + 10 <= input_section->size
2745 && bfd_get_8 (input_bfd,
2746 contents + rel->r_offset + 9) == 0x90)
2747 {
2748 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2749 Change it into:
2750 movl %gs:0, %eax; subl $foo@tpoff, %eax
2751 (6 byte form of subl). */
2752 memcpy (contents + rel->r_offset - 2,
2753 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2754 roff = rel->r_offset + 6;
2755 }
2756 else
2757 {
2758 /* leal foo(%reg), %eax; call ___tls_get_addr
2759 Change it into:
2760 movl %gs:0, %eax; subl $foo@tpoff, %eax
2761 (5 byte form of subl). */
2762 memcpy (contents + rel->r_offset - 2,
2763 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2764 }
2765 }
2766 bfd_put_32 (output_bfd, tpoff (info, relocation),
2767 contents + roff);
2768 /* Skip R_386_PLT32. */
2769 rel++;
2770 continue;
2771 }
2772 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
2773 {
2774 /* GDesc -> LE transition.
2775 It's originally something like:
2776 leal x@tlsdesc(%ebx), %eax
2777
2778 leal x@ntpoff, %eax
2779
2780 Registers other than %eax may be set up here. */
2781
2782 unsigned int val, type;
2783 bfd_vma roff;
2784
2785 /* First, make sure it's a leal adding ebx to a
2786 32-bit offset into any register, although it's
2787 probably almost always going to be eax. */
2788 roff = rel->r_offset;
2789 BFD_ASSERT (roff >= 2);
2790 type = bfd_get_8 (input_bfd, contents + roff - 2);
2791 BFD_ASSERT (type == 0x8d);
2792 val = bfd_get_8 (input_bfd, contents + roff - 1);
2793 BFD_ASSERT ((val & 0xc7) == 0x83);
2794 BFD_ASSERT (roff + 4 <= input_section->size);
2795
2796 /* Now modify the instruction as appropriate. */
2797 /* aoliva FIXME: remove the above and xor the byte
2798 below with 0x86. */
2799 bfd_put_8 (output_bfd, val ^ 0x86,
2800 contents + roff - 1);
2801 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2802 contents + roff);
2803 continue;
2804 }
2805 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
2806 {
2807 /* GDesc -> LE transition.
2808 It's originally:
2809 call *(%eax)
2810 Turn it into:
2811 nop; nop */
2812
2813 unsigned int val, type;
2814 bfd_vma roff;
2815
2816 /* First, make sure it's a call *(%eax). */
2817 roff = rel->r_offset;
2818 BFD_ASSERT (roff + 2 <= input_section->size);
2819 type = bfd_get_8 (input_bfd, contents + roff);
2820 BFD_ASSERT (type == 0xff);
2821 val = bfd_get_8 (input_bfd, contents + roff + 1);
2822 BFD_ASSERT (val == 0x10);
2823
2824 /* Now modify the instruction as appropriate. Use
2825 xchg %ax,%ax instead of 2 nops. */
2826 bfd_put_8 (output_bfd, 0x66, contents + roff);
2827 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2828 continue;
2829 }
2830 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2831 {
2832 unsigned int val, type;
2833
2834 /* IE->LE transition:
2835 Originally it can be one of:
2836 movl foo, %eax
2837 movl foo, %reg
2838 addl foo, %reg
2839 We change it into:
2840 movl $foo, %eax
2841 movl $foo, %reg
2842 addl $foo, %reg. */
2843 BFD_ASSERT (rel->r_offset >= 1);
2844 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2845 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2846 if (val == 0xa1)
2847 {
2848 /* movl foo, %eax. */
2849 bfd_put_8 (output_bfd, 0xb8,
2850 contents + rel->r_offset - 1);
2851 }
2852 else
2853 {
2854 BFD_ASSERT (rel->r_offset >= 2);
2855 type = bfd_get_8 (input_bfd,
2856 contents + rel->r_offset - 2);
2857 switch (type)
2858 {
2859 case 0x8b:
2860 /* movl */
2861 BFD_ASSERT ((val & 0xc7) == 0x05);
2862 bfd_put_8 (output_bfd, 0xc7,
2863 contents + rel->r_offset - 2);
2864 bfd_put_8 (output_bfd,
2865 0xc0 | ((val >> 3) & 7),
2866 contents + rel->r_offset - 1);
2867 break;
2868 case 0x03:
2869 /* addl */
2870 BFD_ASSERT ((val & 0xc7) == 0x05);
2871 bfd_put_8 (output_bfd, 0x81,
2872 contents + rel->r_offset - 2);
2873 bfd_put_8 (output_bfd,
2874 0xc0 | ((val >> 3) & 7),
2875 contents + rel->r_offset - 1);
2876 break;
2877 default:
2878 BFD_FAIL ();
2879 break;
2880 }
2881 }
2882 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2883 contents + rel->r_offset);
2884 continue;
2885 }
2886 else
2887 {
2888 unsigned int val, type;
2889
2890 /* {IE_32,GOTIE}->LE transition:
2891 Originally it can be one of:
2892 subl foo(%reg1), %reg2
2893 movl foo(%reg1), %reg2
2894 addl foo(%reg1), %reg2
2895 We change it into:
2896 subl $foo, %reg2
2897 movl $foo, %reg2 (6 byte form)
2898 addl $foo, %reg2. */
2899 BFD_ASSERT (rel->r_offset >= 2);
2900 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2901 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2902 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2903 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2904 if (type == 0x8b)
2905 {
2906 /* movl */
2907 bfd_put_8 (output_bfd, 0xc7,
2908 contents + rel->r_offset - 2);
2909 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2910 contents + rel->r_offset - 1);
2911 }
2912 else if (type == 0x2b)
2913 {
2914 /* subl */
2915 bfd_put_8 (output_bfd, 0x81,
2916 contents + rel->r_offset - 2);
2917 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2918 contents + rel->r_offset - 1);
2919 }
2920 else if (type == 0x03)
2921 {
2922 /* addl */
2923 bfd_put_8 (output_bfd, 0x81,
2924 contents + rel->r_offset - 2);
2925 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2926 contents + rel->r_offset - 1);
2927 }
2928 else
2929 BFD_FAIL ();
2930 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2931 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2932 contents + rel->r_offset);
2933 else
2934 bfd_put_32 (output_bfd, tpoff (info, relocation),
2935 contents + rel->r_offset);
2936 continue;
2937 }
2938 }
2939
2940 if (htab->sgot == NULL)
2941 abort ();
2942
2943 if (h != NULL)
2944 {
2945 off = h->got.offset;
2946 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
2947 }
2948 else
2949 {
2950 if (local_got_offsets == NULL)
2951 abort ();
2952
2953 off = local_got_offsets[r_symndx];
2954 offplt = local_tlsdesc_gotents[r_symndx];
2955 }
2956
2957 if ((off & 1) != 0)
2958 off &= ~1;
2959 else
2960 {
2961 Elf_Internal_Rela outrel;
2962 bfd_byte *loc;
2963 int dr_type, indx;
2964 asection *sreloc;
2965
2966 if (htab->srelgot == NULL)
2967 abort ();
2968
2969 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2970
2971 if (GOT_TLS_GDESC_P (tls_type))
2972 {
2973 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
2974 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
2975 <= htab->sgotplt->size);
2976 outrel.r_offset = (htab->sgotplt->output_section->vma
2977 + htab->sgotplt->output_offset
2978 + offplt
2979 + htab->sgotplt_jump_table_size);
2980 sreloc = htab->srelplt;
2981 loc = sreloc->contents;
2982 loc += (htab->next_tls_desc_index++
2983 * sizeof (Elf32_External_Rel));
2984 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
2985 <= sreloc->contents + sreloc->size);
2986 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2987 if (indx == 0)
2988 {
2989 BFD_ASSERT (! unresolved_reloc);
2990 bfd_put_32 (output_bfd,
2991 relocation - dtpoff_base (info),
2992 htab->sgotplt->contents + offplt
2993 + htab->sgotplt_jump_table_size + 4);
2994 }
2995 else
2996 {
2997 bfd_put_32 (output_bfd, 0,
2998 htab->sgotplt->contents + offplt
2999 + htab->sgotplt_jump_table_size + 4);
3000 }
3001 }
3002
3003 sreloc = htab->srelgot;
3004
3005 outrel.r_offset = (htab->sgot->output_section->vma
3006 + htab->sgot->output_offset + off);
3007
3008 if (GOT_TLS_GD_P (tls_type))
3009 dr_type = R_386_TLS_DTPMOD32;
3010 else if (GOT_TLS_GDESC_P (tls_type))
3011 goto dr_done;
3012 else if (tls_type == GOT_TLS_IE_POS)
3013 dr_type = R_386_TLS_TPOFF;
3014 else
3015 dr_type = R_386_TLS_TPOFF32;
3016
3017 if (dr_type == R_386_TLS_TPOFF && indx == 0)
3018 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3019 htab->sgot->contents + off);
3020 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3021 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
3022 htab->sgot->contents + off);
3023 else if (dr_type != R_386_TLS_DESC)
3024 bfd_put_32 (output_bfd, 0,
3025 htab->sgot->contents + off);
3026 outrel.r_info = ELF32_R_INFO (indx, dr_type);
3027
3028 loc = sreloc->contents;
3029 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3030 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3031 <= sreloc->contents + sreloc->size);
3032 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3033
3034 if (GOT_TLS_GD_P (tls_type))
3035 {
3036 if (indx == 0)
3037 {
3038 BFD_ASSERT (! unresolved_reloc);
3039 bfd_put_32 (output_bfd,
3040 relocation - dtpoff_base (info),
3041 htab->sgot->contents + off + 4);
3042 }
3043 else
3044 {
3045 bfd_put_32 (output_bfd, 0,
3046 htab->sgot->contents + off + 4);
3047 outrel.r_info = ELF32_R_INFO (indx,
3048 R_386_TLS_DTPOFF32);
3049 outrel.r_offset += 4;
3050 sreloc->reloc_count++;
3051 loc += sizeof (Elf32_External_Rel);
3052 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3053 <= sreloc->contents + sreloc->size);
3054 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3055 }
3056 }
3057 else if (tls_type == GOT_TLS_IE_BOTH)
3058 {
3059 bfd_put_32 (output_bfd,
3060 indx == 0 ? relocation - dtpoff_base (info) : 0,
3061 htab->sgot->contents + off + 4);
3062 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3063 outrel.r_offset += 4;
3064 sreloc->reloc_count++;
3065 loc += sizeof (Elf32_External_Rel);
3066 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3067 }
3068
3069 dr_done:
3070 if (h != NULL)
3071 h->got.offset |= 1;
3072 else
3073 local_got_offsets[r_symndx] |= 1;
3074 }
3075
3076 if (off >= (bfd_vma) -2
3077 && ! GOT_TLS_GDESC_P (tls_type))
3078 abort ();
3079 if (r_type == R_386_TLS_GOTDESC
3080 || r_type == R_386_TLS_DESC_CALL)
3081 {
3082 relocation = htab->sgotplt_jump_table_size + offplt;
3083 unresolved_reloc = FALSE;
3084 }
3085 else if (r_type == ELF32_R_TYPE (rel->r_info))
3086 {
3087 bfd_vma g_o_t = htab->sgotplt->output_section->vma
3088 + htab->sgotplt->output_offset;
3089 relocation = htab->sgot->output_section->vma
3090 + htab->sgot->output_offset + off - g_o_t;
3091 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3092 && tls_type == GOT_TLS_IE_BOTH)
3093 relocation += 4;
3094 if (r_type == R_386_TLS_IE)
3095 relocation += g_o_t;
3096 unresolved_reloc = FALSE;
3097 }
3098 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3099 {
3100 unsigned int val, type;
3101 bfd_vma roff;
3102
3103 /* GD->IE transition. */
3104 BFD_ASSERT (rel->r_offset >= 2);
3105 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3106 BFD_ASSERT (type == 0x8d || type == 0x04);
3107 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3108 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3109 == 0xe8);
3110 BFD_ASSERT (rel + 1 < relend);
3111 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3112 roff = rel->r_offset - 3;
3113 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3114 if (type == 0x04)
3115 {
3116 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3117 Change it into:
3118 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3119 BFD_ASSERT (rel->r_offset >= 3);
3120 BFD_ASSERT (bfd_get_8 (input_bfd,
3121 contents + rel->r_offset - 3)
3122 == 0x8d);
3123 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
3124 val >>= 3;
3125 }
3126 else
3127 {
3128 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3129 Change it into:
3130 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3131 BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
3132 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3133 BFD_ASSERT (bfd_get_8 (input_bfd,
3134 contents + rel->r_offset + 9)
3135 == 0x90);
3136 roff = rel->r_offset - 2;
3137 }
3138 memcpy (contents + roff,
3139 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3140 contents[roff + 7] = 0x80 | (val & 7);
3141 /* If foo is used only with foo@gotntpoff(%reg) and
3142 foo@indntpoff, but not with foo@gottpoff(%reg), change
3143 subl $foo@gottpoff(%reg), %eax
3144 into:
3145 addl $foo@gotntpoff(%reg), %eax. */
3146 if (tls_type == GOT_TLS_IE_POS)
3147 contents[roff + 6] = 0x03;
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 /* xchg %ax,%ax */
3232 bfd_put_8 (output_bfd, 0x66, 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 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
3843
3844 static bfd_boolean
3845 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
3846 {
3847 if (h->plt.offset != (bfd_vma) -1
3848 && !h->def_regular
3849 && !h->pointer_equality_needed)
3850 return FALSE;
3851
3852 return _bfd_elf_hash_symbol (h);
3853 }
3854
3855 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3856 #define TARGET_LITTLE_NAME "elf32-i386"
3857 #define ELF_ARCH bfd_arch_i386
3858 #define ELF_MACHINE_CODE EM_386
3859 #define ELF_MAXPAGESIZE 0x1000
3860
3861 #define elf_backend_can_gc_sections 1
3862 #define elf_backend_can_refcount 1
3863 #define elf_backend_want_got_plt 1
3864 #define elf_backend_plt_readonly 1
3865 #define elf_backend_want_plt_sym 0
3866 #define elf_backend_got_header_size 12
3867
3868 /* Support RELA for objdump of prelink objects. */
3869 #define elf_info_to_howto elf_i386_info_to_howto_rel
3870 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3871
3872 #define bfd_elf32_mkobject elf_i386_mkobject
3873
3874 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3875 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3876 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3877
3878 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3879 #define elf_backend_check_relocs elf_i386_check_relocs
3880 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3881 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3882 #define elf_backend_fake_sections elf_i386_fake_sections
3883 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3884 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3885 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3886 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3887 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3888 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3889 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3890 #define elf_backend_relocate_section elf_i386_relocate_section
3891 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3892 #define elf_backend_always_size_sections elf_i386_always_size_sections
3893 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
3894 #define elf_backend_hash_symbol elf_i386_hash_symbol
3895
3896 #include "elf32-target.h"
3897
3898 /* FreeBSD support. */
3899
3900 #undef TARGET_LITTLE_SYM
3901 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3902 #undef TARGET_LITTLE_NAME
3903 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3904
3905 /* The kernel recognizes executables as valid only if they carry a
3906 "FreeBSD" label in the ELF header. So we put this label on all
3907 executables and (for simplicity) also all other object files. */
3908
3909 static void
3910 elf_i386_post_process_headers (bfd *abfd,
3911 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3912 {
3913 Elf_Internal_Ehdr *i_ehdrp;
3914
3915 i_ehdrp = elf_elfheader (abfd);
3916
3917 /* Put an ABI label supported by FreeBSD >= 4.1. */
3918 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3919 #ifdef OLD_FREEBSD_ABI_LABEL
3920 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3921 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3922 #endif
3923 }
3924
3925 #undef elf_backend_post_process_headers
3926 #define elf_backend_post_process_headers elf_i386_post_process_headers
3927 #undef elf32_bed
3928 #define elf32_bed elf32_i386_fbsd_bed
3929
3930 #include "elf32-target.h"
3931
3932 /* VxWorks support. */
3933
3934 #undef TARGET_LITTLE_SYM
3935 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
3936 #undef TARGET_LITTLE_NAME
3937 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
3938
3939
3940 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
3941
3942 static struct bfd_link_hash_table *
3943 elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3944 {
3945 struct bfd_link_hash_table *ret;
3946 struct elf_i386_link_hash_table *htab;
3947
3948 ret = elf_i386_link_hash_table_create (abfd);
3949 if (ret)
3950 {
3951 htab = (struct elf_i386_link_hash_table *) ret;
3952 htab->is_vxworks = 1;
3953 htab->plt0_pad_byte = 0x90;
3954 }
3955
3956 return ret;
3957 }
3958
3959
3960 #undef elf_backend_post_process_headers
3961 #undef bfd_elf32_bfd_link_hash_table_create
3962 #define bfd_elf32_bfd_link_hash_table_create \
3963 elf_i386_vxworks_link_hash_table_create
3964 #undef elf_backend_add_symbol_hook
3965 #define elf_backend_add_symbol_hook \
3966 elf_vxworks_add_symbol_hook
3967 #undef elf_backend_link_output_symbol_hook
3968 #define elf_backend_link_output_symbol_hook \
3969 elf_vxworks_link_output_symbol_hook
3970 #undef elf_backend_emit_relocs
3971 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
3972 #undef elf_backend_final_write_processing
3973 #define elf_backend_final_write_processing \
3974 elf_vxworks_final_write_processing
3975
3976 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3977 define it. */
3978 #undef elf_backend_want_plt_sym
3979 #define elf_backend_want_plt_sym 1
3980
3981 #undef elf32_bed
3982 #define elf32_bed elf32_i386_vxworks_bed
3983
3984 #include "elf32-target.h"
git-cvsimport of binutils cvsroot