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