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