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