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