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