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