?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* "objcopy -O binary" warning tweak, suggested by dmoseley
[binutils-gdb.git] / bfd / elf32-i386.c
blobb3e34783daeaa76d847d06d78492943c51a27b2c
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993-1997, 1998 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "bfdlink.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25
26 static reloc_howto_type *elf_i386_reloc_type_lookup
27 PARAMS ((bfd *, bfd_reloc_code_real_type));
28 static void elf_i386_info_to_howto
29 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
30 static void elf_i386_info_to_howto_rel
31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
32 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
33 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
36 PARAMS ((bfd *));
37 static boolean elf_i386_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
40 static boolean elf_i386_adjust_dynamic_symbol
41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
42 static boolean elf_i386_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44 static boolean elf_i386_relocate_section
45 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
46 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
47 static boolean elf_i386_finish_dynamic_symbol
48 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
49 Elf_Internal_Sym *));
50 static boolean elf_i386_finish_dynamic_sections
51 PARAMS ((bfd *, struct bfd_link_info *));
52
53 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
54
55 #include "elf/i386.h"
56
57 static reloc_howto_type elf_howto_table[]=
58 {
59 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false),
60 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false),
61 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true),
62 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
63 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
64 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false),
65 HOWTO(R_386_GLOB_DAT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false),
66 HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false),
67 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
68 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
69 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
70 { 11 },
71 { 12 },
72 { 13 },
73 { 14 },
74 { 15 },
75 { 16 },
76 { 17 },
77 { 18 },
78 { 19 },
79 /* The remaining relocs are a GNU extension. */
80 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false),
81 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true),
82 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false),
83 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true),
84 };
85
86 /* GNU extension to record C++ vtable hierarchy. */
87 static reloc_howto_type elf32_i386_vtinherit_howto =
88 HOWTO (R_386_GNU_VTINHERIT, /* type */
89 0, /* rightshift */
90 2, /* size (0 = byte, 1 = short, 2 = long) */
91 0, /* bitsize */
92 false, /* pc_relative */
93 0, /* bitpos */
94 complain_overflow_dont, /* complain_on_overflow */
95 NULL, /* special_function */
96 "R_386_GNU_VTINHERIT", /* name */
97 false, /* partial_inplace */
98 0, /* src_mask */
99 0, /* dst_mask */
100 false);
101
102 /* GNU extension to record C++ vtable member usage. */
103 static reloc_howto_type elf32_i386_vtentry_howto =
104 HOWTO (R_386_GNU_VTENTRY, /* type */
105 0, /* rightshift */
106 2, /* size (0 = byte, 1 = short, 2 = long) */
107 0, /* bitsize */
108 false, /* pc_relative */
109 0, /* bitpos */
110 complain_overflow_dont, /* complain_on_overflow */
111 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
112 "R_386_GNU_VTENTRY", /* name */
113 false, /* partial_inplace */
114 0, /* src_mask */
115 0, /* dst_mask */
116 false);
117
118 #ifdef DEBUG_GEN_RELOC
119 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
120 #else
121 #define TRACE(str)
122 #endif
123
124 static reloc_howto_type *
125 elf_i386_reloc_type_lookup (abfd, code)
126 bfd *abfd;
127 bfd_reloc_code_real_type code;
128 {
129 switch (code)
130 {
131 case BFD_RELOC_NONE:
132 TRACE ("BFD_RELOC_NONE");
133 return &elf_howto_table[ (int)R_386_NONE ];
134
135 case BFD_RELOC_32:
136 TRACE ("BFD_RELOC_32");
137 return &elf_howto_table[ (int)R_386_32 ];
138
139 case BFD_RELOC_32_PCREL:
140 TRACE ("BFD_RELOC_PC32");
141 return &elf_howto_table[ (int)R_386_PC32 ];
142
143 case BFD_RELOC_386_GOT32:
144 TRACE ("BFD_RELOC_386_GOT32");
145 return &elf_howto_table[ (int)R_386_GOT32 ];
146
147 case BFD_RELOC_386_PLT32:
148 TRACE ("BFD_RELOC_386_PLT32");
149 return &elf_howto_table[ (int)R_386_PLT32 ];
150
151 case BFD_RELOC_386_COPY:
152 TRACE ("BFD_RELOC_386_COPY");
153 return &elf_howto_table[ (int)R_386_COPY ];
154
155 case BFD_RELOC_386_GLOB_DAT:
156 TRACE ("BFD_RELOC_386_GLOB_DAT");
157 return &elf_howto_table[ (int)R_386_GLOB_DAT ];
158
159 case BFD_RELOC_386_JUMP_SLOT:
160 TRACE ("BFD_RELOC_386_JUMP_SLOT");
161 return &elf_howto_table[ (int)R_386_JUMP_SLOT ];
162
163 case BFD_RELOC_386_RELATIVE:
164 TRACE ("BFD_RELOC_386_RELATIVE");
165 return &elf_howto_table[ (int)R_386_RELATIVE ];
166
167 case BFD_RELOC_386_GOTOFF:
168 TRACE ("BFD_RELOC_386_GOTOFF");
169 return &elf_howto_table[ (int)R_386_GOTOFF ];
170
171 case BFD_RELOC_386_GOTPC:
172 TRACE ("BFD_RELOC_386_GOTPC");
173 return &elf_howto_table[ (int)R_386_GOTPC ];
174
175 /* The remaining relocs are a GNU extension. */
176 case BFD_RELOC_16:
177 TRACE ("BFD_RELOC_16");
178 return &elf_howto_table[(int) R_386_16];
179
180 case BFD_RELOC_16_PCREL:
181 TRACE ("BFD_RELOC_16_PCREL");
182 return &elf_howto_table[(int) R_386_PC16];
183
184 case BFD_RELOC_8:
185 TRACE ("BFD_RELOC_8");
186 return &elf_howto_table[(int) R_386_8];
187
188 case BFD_RELOC_8_PCREL:
189 TRACE ("BFD_RELOC_8_PCREL");
190 return &elf_howto_table[(int) R_386_PC8];
191
192 case BFD_RELOC_VTABLE_INHERIT:
193 TRACE ("BFD_RELOC_VTABLE_INHERIT");
194 return &elf32_i386_vtinherit_howto;
195
196 case BFD_RELOC_VTABLE_ENTRY:
197 TRACE ("BFD_RELOC_VTABLE_ENTRY");
198 return &elf32_i386_vtentry_howto;
199
200 default:
201 break;
202 }
203
204 TRACE ("Unknown");
205 return 0;
206 }
207
208 static void
209 elf_i386_info_to_howto (abfd, cache_ptr, dst)
210 bfd *abfd;
211 arelent *cache_ptr;
212 Elf32_Internal_Rela *dst;
213 {
214 abort ();
215 }
216
217 static void
218 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
219 bfd *abfd;
220 arelent *cache_ptr;
221 Elf32_Internal_Rel *dst;
222 {
223 enum elf_i386_reloc_type type;
224
225 type = (enum elf_i386_reloc_type) ELF32_R_TYPE (dst->r_info);
226 if (type == R_386_GNU_VTINHERIT)
227 cache_ptr->howto = &elf32_i386_vtinherit_howto;
228 else if (type == R_386_GNU_VTENTRY)
229 cache_ptr->howto = &elf32_i386_vtentry_howto;
230 else
231 {
232 BFD_ASSERT (type < R_386_max);
233 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC);
234 cache_ptr->howto = &elf_howto_table[(int) type];
235 }
236 }
237
238 /* Return whether a symbol name implies a local label. The UnixWare
239 2.1 cc generates temporary symbols that start with .X, so we
240 recognize them here. FIXME: do other SVR4 compilers also use .X?.
241 If so, we should move the .X recognition into
242 _bfd_elf_is_local_label_name. */
243
244 static boolean
245 elf_i386_is_local_label_name (abfd, name)
246 bfd *abfd;
247 const char *name;
248 {
249 if (name[0] == '.' && name[1] == 'X')
250 return true;
251
252 return _bfd_elf_is_local_label_name (abfd, name);
253 }
254 \f
255 /* Functions for the i386 ELF linker. */
256
257 /* The name of the dynamic interpreter. This is put in the .interp
258 section. */
259
260 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
261
262 /* The size in bytes of an entry in the procedure linkage table. */
263
264 #define PLT_ENTRY_SIZE 16
265
266 /* The first entry in an absolute procedure linkage table looks like
267 this. See the SVR4 ABI i386 supplement to see how this works. */
268
269 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
270 {
271 0xff, 0x35, /* pushl contents of address */
272 0, 0, 0, 0, /* replaced with address of .got + 4. */
273 0xff, 0x25, /* jmp indirect */
274 0, 0, 0, 0, /* replaced with address of .got + 8. */
275 0, 0, 0, 0 /* pad out to 16 bytes. */
276 };
277
278 /* Subsequent entries in an absolute procedure linkage table look like
279 this. */
280
281 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
282 {
283 0xff, 0x25, /* jmp indirect */
284 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
285 0x68, /* pushl immediate */
286 0, 0, 0, 0, /* replaced with offset into relocation table. */
287 0xe9, /* jmp relative */
288 0, 0, 0, 0 /* replaced with offset to start of .plt. */
289 };
290
291 /* The first entry in a PIC procedure linkage table look like this. */
292
293 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
294 {
295 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
296 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
297 0, 0, 0, 0 /* pad out to 16 bytes. */
298 };
299
300 /* Subsequent entries in a PIC procedure linkage table look like this. */
301
302 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
303 {
304 0xff, 0xa3, /* jmp *offset(%ebx) */
305 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
306 0x68, /* pushl immediate */
307 0, 0, 0, 0, /* replaced with offset into relocation table. */
308 0xe9, /* jmp relative */
309 0, 0, 0, 0 /* replaced with offset to start of .plt. */
310 };
311
312 /* The i386 linker needs to keep track of the number of relocs that it
313 decides to copy in check_relocs for each symbol. This is so that
314 it can discard PC relative relocs if it doesn't need them when
315 linking with -Bsymbolic. We store the information in a field
316 extending the regular ELF linker hash table. */
317
318 /* This structure keeps track of the number of PC relative relocs we
319 have copied for a given symbol. */
320
321 struct elf_i386_pcrel_relocs_copied
322 {
323 /* Next section. */
324 struct elf_i386_pcrel_relocs_copied *next;
325 /* A section in dynobj. */
326 asection *section;
327 /* Number of relocs copied in this section. */
328 bfd_size_type count;
329 };
330
331 /* i386 ELF linker hash entry. */
332
333 struct elf_i386_link_hash_entry
334 {
335 struct elf_link_hash_entry root;
336
337 /* Number of PC relative relocs copied for this symbol. */
338 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
339 };
340
341 /* i386 ELF linker hash table. */
342
343 struct elf_i386_link_hash_table
344 {
345 struct elf_link_hash_table root;
346 };
347
348 /* Declare this now that the above structures are defined. */
349
350 static boolean elf_i386_discard_copies
351 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
352
353 /* Traverse an i386 ELF linker hash table. */
354
355 #define elf_i386_link_hash_traverse(table, func, info) \
356 (elf_link_hash_traverse \
357 (&(table)->root, \
358 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
359 (info)))
360
361 /* Get the i386 ELF linker hash table from a link_info structure. */
362
363 #define elf_i386_hash_table(p) \
364 ((struct elf_i386_link_hash_table *) ((p)->hash))
365
366 /* Create an entry in an i386 ELF linker hash table. */
367
368 static struct bfd_hash_entry *
369 elf_i386_link_hash_newfunc (entry, table, string)
370 struct bfd_hash_entry *entry;
371 struct bfd_hash_table *table;
372 const char *string;
373 {
374 struct elf_i386_link_hash_entry *ret =
375 (struct elf_i386_link_hash_entry *) entry;
376
377 /* Allocate the structure if it has not already been allocated by a
378 subclass. */
379 if (ret == (struct elf_i386_link_hash_entry *) NULL)
380 ret = ((struct elf_i386_link_hash_entry *)
381 bfd_hash_allocate (table,
382 sizeof (struct elf_i386_link_hash_entry)));
383 if (ret == (struct elf_i386_link_hash_entry *) NULL)
384 return (struct bfd_hash_entry *) ret;
385
386 /* Call the allocation method of the superclass. */
387 ret = ((struct elf_i386_link_hash_entry *)
388 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
389 table, string));
390 if (ret != (struct elf_i386_link_hash_entry *) NULL)
391 {
392 ret->pcrel_relocs_copied = NULL;
393 }
394
395 return (struct bfd_hash_entry *) ret;
396 }
397
398 /* Create an i386 ELF linker hash table. */
399
400 static struct bfd_link_hash_table *
401 elf_i386_link_hash_table_create (abfd)
402 bfd *abfd;
403 {
404 struct elf_i386_link_hash_table *ret;
405
406 ret = ((struct elf_i386_link_hash_table *)
407 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
408 if (ret == (struct elf_i386_link_hash_table *) NULL)
409 return NULL;
410
411 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
412 elf_i386_link_hash_newfunc))
413 {
414 bfd_release (abfd, ret);
415 return NULL;
416 }
417
418 return &ret->root.root;
419 }
420
421 /* Look through the relocs for a section during the first phase, and
422 allocate space in the global offset table or procedure linkage
423 table. */
424
425 static boolean
426 elf_i386_check_relocs (abfd, info, sec, relocs)
427 bfd *abfd;
428 struct bfd_link_info *info;
429 asection *sec;
430 const Elf_Internal_Rela *relocs;
431 {
432 bfd *dynobj;
433 Elf_Internal_Shdr *symtab_hdr;
434 struct elf_link_hash_entry **sym_hashes;
435 bfd_vma *local_got_offsets;
436 const Elf_Internal_Rela *rel;
437 const Elf_Internal_Rela *rel_end;
438 asection *sgot;
439 asection *srelgot;
440 asection *sreloc;
441
442 if (info->relocateable)
443 return true;
444
445 dynobj = elf_hash_table (info)->dynobj;
446 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
447 sym_hashes = elf_sym_hashes (abfd);
448 local_got_offsets = elf_local_got_offsets (abfd);
449
450 sgot = NULL;
451 srelgot = NULL;
452 sreloc = NULL;
453
454 rel_end = relocs + sec->reloc_count;
455 for (rel = relocs; rel < rel_end; rel++)
456 {
457 unsigned long r_symndx;
458 struct elf_link_hash_entry *h;
459
460 r_symndx = ELF32_R_SYM (rel->r_info);
461
462 if (r_symndx < symtab_hdr->sh_info)
463 h = NULL;
464 else
465 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
466
467 /* Some relocs require a global offset table. */
468 if (dynobj == NULL)
469 {
470 switch (ELF32_R_TYPE (rel->r_info))
471 {
472 case R_386_GOT32:
473 case R_386_GOTOFF:
474 case R_386_GOTPC:
475 elf_hash_table (info)->dynobj = dynobj = abfd;
476 if (! _bfd_elf_create_got_section (dynobj, info))
477 return false;
478 break;
479
480 default:
481 break;
482 }
483 }
484
485 switch (ELF32_R_TYPE (rel->r_info))
486 {
487 case R_386_GOT32:
488 /* This symbol requires a global offset table entry. */
489
490 if (sgot == NULL)
491 {
492 sgot = bfd_get_section_by_name (dynobj, ".got");
493 BFD_ASSERT (sgot != NULL);
494 }
495
496 if (srelgot == NULL
497 && (h != NULL || info->shared))
498 {
499 const char *srelgot_name;
500
501 srelgot_name = info->combine_reloc ? ".gnu.reloc" : ".rel.got";
502
503 srelgot = bfd_get_section_by_name (dynobj, srelgot_name);
504 if (srelgot == NULL)
505 {
506 srelgot = bfd_make_section (dynobj, srelgot_name);
507 if (srelgot == NULL
508 || ! bfd_set_section_flags (dynobj, srelgot,
509 (SEC_ALLOC
510 | SEC_LOAD
511 | SEC_HAS_CONTENTS
512 | SEC_IN_MEMORY
513 | SEC_LINKER_CREATED
514 | SEC_READONLY))
515 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
516 return false;
517 }
518 }
519
520 if (h != NULL)
521 {
522 if (h->got.offset != (bfd_vma) -1)
523 {
524 /* We have already allocated space in the .got. */
525 break;
526 }
527 h->got.offset = sgot->_raw_size;
528
529 /* Make sure this symbol is output as a dynamic symbol. */
530 if (h->dynindx == -1)
531 {
532 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
533 return false;
534 }
535
536 srelgot->_raw_size += sizeof (Elf32_External_Rel);
537 }
538 else
539 {
540 /* This is a global offset table entry for a local
541 symbol. */
542 if (local_got_offsets == NULL)
543 {
544 size_t size;
545 register unsigned int i;
546
547 size = symtab_hdr->sh_info * sizeof (bfd_vma);
548 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
549 if (local_got_offsets == NULL)
550 return false;
551 elf_local_got_offsets (abfd) = local_got_offsets;
552 for (i = 0; i < symtab_hdr->sh_info; i++)
553 local_got_offsets[i] = (bfd_vma) -1;
554 }
555 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
556 {
557 /* We have already allocated space in the .got. */
558 break;
559 }
560 local_got_offsets[r_symndx] = sgot->_raw_size;
561
562 if (info->shared)
563 {
564 /* If we are generating a shared object, we need to
565 output a R_386_RELATIVE reloc so that the dynamic
566 linker can adjust this GOT entry. */
567 srelgot->_raw_size += sizeof (Elf32_External_Rel);
568 }
569 }
570
571 sgot->_raw_size += 4;
572
573 break;
574
575 case R_386_PLT32:
576 /* This symbol requires a procedure linkage table entry. We
577 actually build the entry in adjust_dynamic_symbol,
578 because this might be a case of linking PIC code which is
579 never referenced by a dynamic object, in which case we
580 don't need to generate a procedure linkage table entry
581 after all. */
582
583 /* If this is a local symbol, we resolve it directly without
584 creating a procedure linkage table entry. */
585 if (h == NULL)
586 continue;
587
588 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
589
590 break;
591
592 case R_386_32:
593 case R_386_PC32:
594 /* If we are creating a shared library, and this is a reloc
595 against a global symbol, or a non PC relative reloc
596 against a local symbol, then we need to copy the reloc
597 into the shared library. However, if we are linking with
598 -Bsymbolic, we do not need to copy a reloc against a
599 global symbol which is defined in an object we are
600 including in the link (i.e., DEF_REGULAR is set). At
601 this point we have not seen all the input files, so it is
602 possible that DEF_REGULAR is not set now but will be set
603 later (it is never cleared). We account for that
604 possibility below by storing information in the
605 pcrel_relocs_copied field of the hash table entry. */
606 if (info->shared
607 && (sec->flags & SEC_ALLOC) != 0
608 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
609 || (h != NULL
610 && (! info->symbolic
611 || (h->elf_link_hash_flags
612 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
613 {
614 /* When creating a shared object, we must copy these
615 reloc types into the output file. We create a reloc
616 section in dynobj and make room for this reloc. */
617 if (sreloc == NULL)
618 {
619 const char *name;
620
621 name = (bfd_elf_string_from_elf_section
622 (abfd,
623 elf_elfheader (abfd)->e_shstrndx,
624 elf_section_data (sec)->rel_hdr.sh_name));
625 if (name == NULL)
626 return false;
627
628 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
629 && strcmp (bfd_get_section_name (abfd, sec),
630 name + 4) == 0);
631
632 if (info->combine_reloc)
633 /* If we combine the relocation sections use change
634 the name here. */
635 name = ".gnu.reloc";
636
637 sreloc = bfd_get_section_by_name (dynobj, name);
638 if (sreloc == NULL)
639 {
640 flagword flags;
641
642 sreloc = bfd_make_section (dynobj, name);
643 flags = (SEC_HAS_CONTENTS | SEC_READONLY
644 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
645 if ((sec->flags & SEC_ALLOC) != 0)
646 flags |= SEC_ALLOC | SEC_LOAD;
647 if (sreloc == NULL
648 || ! bfd_set_section_flags (dynobj, sreloc, flags)
649 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
650 return false;
651 }
652 }
653
654 sreloc->_raw_size += sizeof (Elf32_External_Rel);
655
656 /* If we are linking with -Bsymbolic, and this is a
657 global symbol, we count the number of PC relative
658 relocations we have entered for this symbol, so that
659 we can discard them again if the symbol is later
660 defined by a regular object. Note that this function
661 is only called if we are using an elf_i386 linker
662 hash table, which means that h is really a pointer to
663 an elf_i386_link_hash_entry. */
664 if (h != NULL && info->symbolic
665 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
666 {
667 struct elf_i386_link_hash_entry *eh;
668 struct elf_i386_pcrel_relocs_copied *p;
669
670 eh = (struct elf_i386_link_hash_entry *) h;
671
672 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
673 if (p->section == sreloc)
674 break;
675
676 if (p == NULL)
677 {
678 p = ((struct elf_i386_pcrel_relocs_copied *)
679 bfd_alloc (dynobj, sizeof *p));
680 if (p == NULL)
681 return false;
682 p->next = eh->pcrel_relocs_copied;
683 eh->pcrel_relocs_copied = p;
684 p->section = sreloc;
685 p->count = 0;
686 }
687
688 ++p->count;
689 }
690 }
691
692 break;
693
694 /* This relocation describes the C++ object vtable hierarchy.
695 Reconstruct it for later use during GC. */
696 case R_386_GNU_VTINHERIT:
697 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
698 return false;
699 break;
700
701 /* This relocation describes which C++ vtable entries are actually
702 used. Record for later use during GC. */
703 case R_386_GNU_VTENTRY:
704 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
705 return false;
706 break;
707
708 default:
709 break;
710 }
711 }
712
713 return true;
714 }
715
716 /* Return the section that should be marked against GC for a given
717 relocation. */
718
719 static asection *
720 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
721 bfd *abfd;
722 struct bfd_link_info *info;
723 Elf_Internal_Rela *rel;
724 struct elf_link_hash_entry *h;
725 Elf_Internal_Sym *sym;
726 {
727 if (h != NULL)
728 {
729 switch (ELF32_R_TYPE (rel->r_info))
730 {
731 case R_386_GNU_VTINHERIT:
732 case R_386_GNU_VTENTRY:
733 break;
734
735 default:
736 switch (h->root.type)
737 {
738 case bfd_link_hash_defined:
739 case bfd_link_hash_defweak:
740 return h->root.u.def.section;
741
742 case bfd_link_hash_common:
743 return h->root.u.c.p->section;
744 }
745 }
746 }
747 else
748 {
749 if (!(elf_bad_symtab (abfd)
750 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
751 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
752 && sym->st_shndx != SHN_COMMON))
753 {
754 return bfd_section_from_elf_index (abfd, sym->st_shndx);
755 }
756 }
757
758 return NULL;
759 }
760
761 /* Update the got entry reference counts for the section being removed. */
762
763 static boolean
764 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
765 bfd *abfd;
766 struct bfd_link_info *info;
767 asection *sec;
768 const Elf_Internal_Rela *relocs;
769 {
770 /* ??? It would seem that the existing i386 code does no sort
771 of reference counting or whatnot on its GOT and PLT entries,
772 so it is not possible to garbage collect them at this time. */
773
774 return true;
775 }
776
777 /* Adjust a symbol defined by a dynamic object and referenced by a
778 regular object. The current definition is in some section of the
779 dynamic object, but we're not including those sections. We have to
780 change the definition to something the rest of the link can
781 understand. */
782
783 static boolean
784 elf_i386_adjust_dynamic_symbol (info, h)
785 struct bfd_link_info *info;
786 struct elf_link_hash_entry *h;
787 {
788 bfd *dynobj;
789 asection *s;
790 unsigned int power_of_two;
791
792 dynobj = elf_hash_table (info)->dynobj;
793
794 /* Make sure we know what is going on here. */
795 BFD_ASSERT (dynobj != NULL
796 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
797 || h->weakdef != NULL
798 || ((h->elf_link_hash_flags
799 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
800 && (h->elf_link_hash_flags
801 & ELF_LINK_HASH_REF_REGULAR) != 0
802 && (h->elf_link_hash_flags
803 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
804
805 /* If this is a function, put it in the procedure linkage table. We
806 will fill in the contents of the procedure linkage table later,
807 when we know the address of the .got section. */
808 if (h->type == STT_FUNC
809 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
810 {
811 if (! info->shared
812 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
813 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
814 {
815 /* This case can occur if we saw a PLT32 reloc in an input
816 file, but the symbol was never referred to by a dynamic
817 object. In such a case, we don't actually need to build
818 a procedure linkage table, and we can just do a PC32
819 reloc instead. */
820 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
821 return true;
822 }
823
824 /* Make sure this symbol is output as a dynamic symbol. */
825 if (h->dynindx == -1)
826 {
827 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
828 return false;
829 }
830
831 s = bfd_get_section_by_name (dynobj, ".plt");
832 BFD_ASSERT (s != NULL);
833
834 /* If this is the first .plt entry, make room for the special
835 first entry. */
836 if (s->_raw_size == 0)
837 s->_raw_size += PLT_ENTRY_SIZE;
838
839 /* If this symbol is not defined in a regular file, and we are
840 not generating a shared library, then set the symbol to this
841 location in the .plt. This is required to make function
842 pointers compare as equal between the normal executable and
843 the shared library. */
844 if (! info->shared
845 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
846 {
847 h->root.u.def.section = s;
848 h->root.u.def.value = s->_raw_size;
849 }
850
851 h->plt.offset = s->_raw_size;
852
853 /* Make room for this entry. */
854 s->_raw_size += PLT_ENTRY_SIZE;
855
856 /* We also need to make an entry in the .got.plt section, which
857 will be placed in the .got section by the linker script. */
858
859 s = bfd_get_section_by_name (dynobj, ".got.plt");
860 BFD_ASSERT (s != NULL);
861 s->_raw_size += 4;
862
863 /* We also need to make an entry in the .rel.plt section. */
864
865 s = bfd_get_section_by_name (dynobj, ".rel.plt");
866 BFD_ASSERT (s != NULL);
867 s->_raw_size += sizeof (Elf32_External_Rel);
868
869 return true;
870 }
871
872 /* If this is a weak symbol, and there is a real definition, the
873 processor independent code will have arranged for us to see the
874 real definition first, and we can just use the same value. */
875 if (h->weakdef != NULL)
876 {
877 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
878 || h->weakdef->root.type == bfd_link_hash_defweak);
879 h->root.u.def.section = h->weakdef->root.u.def.section;
880 h->root.u.def.value = h->weakdef->root.u.def.value;
881 return true;
882 }
883
884 /* This is a reference to a symbol defined by a dynamic object which
885 is not a function. */
886
887 /* If we are creating a shared library, we must presume that the
888 only references to the symbol are via the global offset table.
889 For such cases we need not do anything here; the relocations will
890 be handled correctly by relocate_section. */
891 if (info->shared)
892 return true;
893
894 /* We must allocate the symbol in our .dynbss section, which will
895 become part of the .bss section of the executable. There will be
896 an entry for this symbol in the .dynsym section. The dynamic
897 object will contain position independent code, so all references
898 from the dynamic object to this symbol will go through the global
899 offset table. The dynamic linker will use the .dynsym entry to
900 determine the address it must put in the global offset table, so
901 both the dynamic object and the regular object will refer to the
902 same memory location for the variable. */
903
904 s = bfd_get_section_by_name (dynobj, ".dynbss");
905 BFD_ASSERT (s != NULL);
906
907 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
908 copy the initial value out of the dynamic object and into the
909 runtime process image. We need to remember the offset into the
910 .rel.bss section we are going to use. */
911 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
912 {
913 asection *srel;
914 const char *srel_name = info->combine_reloc ? ".gnu.reloc" : ".rel.bss";
915
916 srel = bfd_get_section_by_name (dynobj, srel_name);
917 BFD_ASSERT (srel != NULL);
918 srel->_raw_size += sizeof (Elf32_External_Rel);
919 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
920 }
921
922 /* We need to figure out the alignment required for this symbol. I
923 have no idea how ELF linkers handle this. */
924 power_of_two = bfd_log2 (h->size);
925 if (power_of_two > 3)
926 power_of_two = 3;
927
928 /* Apply the required alignment. */
929 s->_raw_size = BFD_ALIGN (s->_raw_size,
930 (bfd_size_type) (1 << power_of_two));
931 if (power_of_two > bfd_get_section_alignment (dynobj, s))
932 {
933 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
934 return false;
935 }
936
937 /* Define the symbol as being at this point in the section. */
938 h->root.u.def.section = s;
939 h->root.u.def.value = s->_raw_size;
940
941 /* Increment the section size to make room for the symbol. */
942 s->_raw_size += h->size;
943
944 return true;
945 }
946
947 /* Set the sizes of the dynamic sections. */
948
949 static boolean
950 elf_i386_size_dynamic_sections (output_bfd, info)
951 bfd *output_bfd;
952 struct bfd_link_info *info;
953 {
954 bfd *dynobj;
955 asection *s;
956 boolean plt;
957 boolean relocs;
958 boolean reltext;
959
960 dynobj = elf_hash_table (info)->dynobj;
961 BFD_ASSERT (dynobj != NULL);
962
963 if (elf_hash_table (info)->dynamic_sections_created)
964 {
965 /* Set the contents of the .interp section to the interpreter. */
966 if (! info->shared)
967 {
968 s = bfd_get_section_by_name (dynobj, ".interp");
969 BFD_ASSERT (s != NULL);
970 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
971 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
972 }
973 }
974 else
975 {
976 /* We may have created entries in the .rel.got section.
977 However, if we are not creating the dynamic sections, we will
978 not actually use these entries. Reset the size of .rel.got,
979 which will cause it to get stripped from the output file
980 below. */
981 const char *s_name = info->combine_reloc ? ".gnu.reloc" : ".rel.got";
982
983 s = bfd_get_section_by_name (dynobj, s_name);
984 if (s != NULL)
985 s->_raw_size = 0;
986 }
987
988 /* If this is a -Bsymbolic shared link, then we need to discard all
989 PC relative relocs against symbols defined in a regular object.
990 We allocated space for them in the check_relocs routine, but we
991 will not fill them in in the relocate_section routine. */
992 if (info->shared && info->symbolic)
993 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
994 elf_i386_discard_copies,
995 (PTR) NULL);
996
997 /* The check_relocs and adjust_dynamic_symbol entry points have
998 determined the sizes of the various dynamic sections. Allocate
999 memory for them. */
1000 plt = false;
1001 relocs = false;
1002 reltext = false;
1003 for (s = dynobj->sections; s != NULL; s = s->next)
1004 {
1005 const char *name;
1006 boolean strip;
1007
1008 if ((s->flags & SEC_LINKER_CREATED) == 0)
1009 continue;
1010
1011 /* It's OK to base decisions on the section name, because none
1012 of the dynobj section names depend upon the input files. */
1013 name = bfd_get_section_name (dynobj, s);
1014
1015 strip = false;
1016
1017 if (strcmp (name, ".plt") == 0)
1018 {
1019 if (s->_raw_size == 0)
1020 {
1021 /* Strip this section if we don't need it; see the
1022 comment below. */
1023 strip = true;
1024 }
1025 else
1026 {
1027 /* Remember whether there is a PLT. */
1028 plt = true;
1029 }
1030 }
1031 else if (strncmp (name, ".rel", 4) == 0
1032 || strcmp (name, ".gnu.reloc") == 0)
1033 {
1034 if (s->_raw_size == 0)
1035 {
1036 /* If we don't need this section, strip it from the
1037 output file. This is mostly to handle .rel.bss and
1038 .rel.plt. We must create both sections in
1039 create_dynamic_sections, because they must be created
1040 before the linker maps input sections to output
1041 sections. The linker does that before
1042 adjust_dynamic_symbol is called, and it is that
1043 function which decides whether anything needs to go
1044 into these sections. */
1045 strip = true;
1046 }
1047 else
1048 {
1049 asection *target;
1050
1051 /* Remember whether there are any reloc sections other
1052 than .rel.plt. */
1053 if (strcmp (name, ".rel.plt") != 0)
1054 {
1055 const char *outname;
1056
1057 relocs = true;
1058
1059 /* If this relocation section applies to a read only
1060 section, then we probably need a DT_TEXTREL
1061 entry. The entries in the .rel.plt section
1062 really apply to the .got section, which we
1063 created ourselves and so know is not readonly. */
1064 outname = bfd_get_section_name (output_bfd,
1065 s->output_section);
1066 target = bfd_get_section_by_name (output_bfd, outname + 4);
1067 if (target != NULL
1068 && (target->flags & SEC_READONLY) != 0
1069 && (target->flags & SEC_ALLOC) != 0)
1070 reltext = true;
1071 }
1072
1073 /* We use the reloc_count field as a counter if we need
1074 to copy relocs into the output file. */
1075 s->reloc_count = 0;
1076 }
1077 }
1078 else if (strncmp (name, ".got", 4) != 0)
1079 {
1080 /* It's not one of our sections, so don't allocate space. */
1081 continue;
1082 }
1083
1084 if (strip)
1085 {
1086 asection **spp;
1087
1088 for (spp = &s->output_section->owner->sections;
1089 *spp != s->output_section;
1090 spp = &(*spp)->next)
1091 ;
1092 *spp = s->output_section->next;
1093 --s->output_section->owner->section_count;
1094
1095 continue;
1096 }
1097
1098 /* Allocate memory for the section contents. */
1099 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1100 if (s->contents == NULL && s->_raw_size != 0)
1101 return false;
1102 }
1103
1104 if (elf_hash_table (info)->dynamic_sections_created)
1105 {
1106 /* Add some entries to the .dynamic section. We fill in the
1107 values later, in elf_i386_finish_dynamic_sections, but we
1108 must add the entries now so that we get the correct size for
1109 the .dynamic section. The DT_DEBUG entry is filled in by the
1110 dynamic linker and used by the debugger. */
1111 if (! info->shared)
1112 {
1113 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1114 return false;
1115 }
1116
1117 if (plt)
1118 {
1119 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1120 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1121 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1122 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1123 return false;
1124 }
1125
1126 if (relocs)
1127 {
1128 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1129 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1130 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1131 sizeof (Elf32_External_Rel)))
1132 return false;
1133 }
1134
1135 if (reltext)
1136 {
1137 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1138 return false;
1139 }
1140 }
1141
1142 return true;
1143 }
1144
1145 /* This function is called via elf_i386_link_hash_traverse if we are
1146 creating a shared object with -Bsymbolic. It discards the space
1147 allocated to copy PC relative relocs against symbols which are
1148 defined in regular objects. We allocated space for them in the
1149 check_relocs routine, but we won't fill them in in the
1150 relocate_section routine. */
1151
1152 /*ARGSUSED*/
1153 static boolean
1154 elf_i386_discard_copies (h, ignore)
1155 struct elf_i386_link_hash_entry *h;
1156 PTR ignore;
1157 {
1158 struct elf_i386_pcrel_relocs_copied *s;
1159
1160 /* We only discard relocs for symbols defined in a regular object. */
1161 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1162 return true;
1163
1164 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1165 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1166
1167 return true;
1168 }
1169
1170 /* Relocate an i386 ELF section. */
1171
1172 static boolean
1173 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1174 contents, relocs, local_syms, local_sections)
1175 bfd *output_bfd;
1176 struct bfd_link_info *info;
1177 bfd *input_bfd;
1178 asection *input_section;
1179 bfd_byte *contents;
1180 Elf_Internal_Rela *relocs;
1181 Elf_Internal_Sym *local_syms;
1182 asection **local_sections;
1183 {
1184 bfd *dynobj;
1185 Elf_Internal_Shdr *symtab_hdr;
1186 struct elf_link_hash_entry **sym_hashes;
1187 bfd_vma *local_got_offsets;
1188 asection *sgot;
1189 asection *splt;
1190 asection *sreloc;
1191 Elf_Internal_Rela *rel;
1192 Elf_Internal_Rela *relend;
1193
1194 dynobj = elf_hash_table (info)->dynobj;
1195 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1196 sym_hashes = elf_sym_hashes (input_bfd);
1197 local_got_offsets = elf_local_got_offsets (input_bfd);
1198
1199 sgot = NULL;
1200 splt = NULL;
1201 sreloc = NULL;
1202
1203 rel = relocs;
1204 relend = relocs + input_section->reloc_count;
1205 for (; rel < relend; rel++)
1206 {
1207 int r_type;
1208 reloc_howto_type *howto;
1209 unsigned long r_symndx;
1210 struct elf_link_hash_entry *h;
1211 Elf_Internal_Sym *sym;
1212 asection *sec;
1213 bfd_vma relocation;
1214 bfd_reloc_status_type r;
1215
1216 r_type = ELF32_R_TYPE (rel->r_info);
1217 if (r_type == R_386_GNU_VTINHERIT
1218 || r_type == R_386_GNU_VTENTRY)
1219 continue;
1220 if (r_type < 0
1221 || r_type >= (int) R_386_max
1222 || (r_type >= (int) FIRST_INVALID_RELOC
1223 && r_type <= (int) LAST_INVALID_RELOC))
1224 {
1225 bfd_set_error (bfd_error_bad_value);
1226 return false;
1227 }
1228 howto = elf_howto_table + r_type;
1229
1230 r_symndx = ELF32_R_SYM (rel->r_info);
1231
1232 if (info->relocateable)
1233 {
1234 /* This is a relocateable link. We don't have to change
1235 anything, unless the reloc is against a section symbol,
1236 in which case we have to adjust according to where the
1237 section symbol winds up in the output section. */
1238 if (r_symndx < symtab_hdr->sh_info)
1239 {
1240 sym = local_syms + r_symndx;
1241 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1242 {
1243 bfd_vma val;
1244
1245 sec = local_sections[r_symndx];
1246 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1247 val += sec->output_offset + sym->st_value;
1248 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1249 }
1250 }
1251
1252 continue;
1253 }
1254
1255 /* This is a final link. */
1256 h = NULL;
1257 sym = NULL;
1258 sec = NULL;
1259 if (r_symndx < symtab_hdr->sh_info)
1260 {
1261 sym = local_syms + r_symndx;
1262 sec = local_sections[r_symndx];
1263 relocation = (sec->output_section->vma
1264 + sec->output_offset
1265 + sym->st_value);
1266 }
1267 else
1268 {
1269 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1270 while (h->root.type == bfd_link_hash_indirect
1271 || h->root.type == bfd_link_hash_warning)
1272 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1273 if (h->root.type == bfd_link_hash_defined
1274 || h->root.type == bfd_link_hash_defweak)
1275 {
1276 sec = h->root.u.def.section;
1277 if (r_type == R_386_GOTPC
1278 || (r_type == R_386_PLT32
1279 && h->plt.offset != (bfd_vma) -1)
1280 || (r_type == R_386_GOT32
1281 && elf_hash_table (info)->dynamic_sections_created
1282 && (! info->shared
1283 || (! info->symbolic && h->dynindx != -1)
1284 || (h->elf_link_hash_flags
1285 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1286 || (info->shared
1287 && ((! info->symbolic && h->dynindx != -1)
1288 || (h->elf_link_hash_flags
1289 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1290 && (r_type == R_386_32
1291 || r_type == R_386_PC32)
1292 && ((input_section->flags & SEC_ALLOC) != 0
1293 /* DWARF will emit R_386_32 relocations in its
1294 sections against symbols defined externally
1295 in shared libraries. We can't do anything
1296 with them here. */
1297 || (input_section->flags & SEC_DEBUGGING) != 0)))
1298 {
1299 /* In these cases, we don't need the relocation
1300 value. We check specially because in some
1301 obscure cases sec->output_section will be NULL. */
1302 relocation = 0;
1303 }
1304 else if (sec->output_section == NULL)
1305 {
1306 (*_bfd_error_handler)
1307 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1308 bfd_get_filename (input_bfd), h->root.root.string,
1309 bfd_get_section_name (input_bfd, input_section));
1310 relocation = 0;
1311 }
1312 else
1313 relocation = (h->root.u.def.value
1314 + sec->output_section->vma
1315 + sec->output_offset);
1316 }
1317 else if (h->root.type == bfd_link_hash_undefweak)
1318 relocation = 0;
1319 else if (info->shared && !info->symbolic)
1320 relocation = 0;
1321 else
1322 {
1323 if (! ((*info->callbacks->undefined_symbol)
1324 (info, h->root.root.string, input_bfd,
1325 input_section, rel->r_offset)))
1326 return false;
1327 relocation = 0;
1328 }
1329 }
1330
1331 switch (r_type)
1332 {
1333 case R_386_GOT32:
1334 /* Relocation is to the entry for this symbol in the global
1335 offset table. */
1336 if (sgot == NULL)
1337 {
1338 sgot = bfd_get_section_by_name (dynobj, ".got");
1339 BFD_ASSERT (sgot != NULL);
1340 }
1341
1342 if (h != NULL)
1343 {
1344 bfd_vma off;
1345
1346 off = h->got.offset;
1347 BFD_ASSERT (off != (bfd_vma) -1);
1348
1349 if (! elf_hash_table (info)->dynamic_sections_created
1350 || (info->shared
1351 && (info->symbolic || h->dynindx == -1)
1352 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1353 {
1354 /* This is actually a static link, or it is a
1355 -Bsymbolic link and the symbol is defined
1356 locally, or the symbol was forced to be local
1357 because of a version file. We must initialize
1358 this entry in the global offset table. Since the
1359 offset must always be a multiple of 4, we use the
1360 least significant bit to record whether we have
1361 initialized it already.
1362
1363 When doing a dynamic link, we create a .rel.got
1364 relocation entry to initialize the value. This
1365 is done in the finish_dynamic_symbol routine. */
1366 if ((off & 1) != 0)
1367 off &= ~1;
1368 else
1369 {
1370 bfd_put_32 (output_bfd, relocation,
1371 sgot->contents + off);
1372 h->got.offset |= 1;
1373 }
1374 }
1375
1376 relocation = sgot->output_offset + off;
1377 }
1378 else
1379 {
1380 bfd_vma off;
1381
1382 BFD_ASSERT (local_got_offsets != NULL
1383 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1384
1385 off = local_got_offsets[r_symndx];
1386
1387 /* The offset must always be a multiple of 4. We use
1388 the least significant bit to record whether we have
1389 already generated the necessary reloc. */
1390 if ((off & 1) != 0)
1391 off &= ~1;
1392 else
1393 {
1394 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1395
1396 if (info->shared)
1397 {
1398 asection *srelgot;
1399 Elf_Internal_Rel outrel;
1400 const char *srelgot_name;
1401
1402 srelgot_name = (info->combine_reloc
1403 ? ".gnu.reloc" : ".rel.got");
1404
1405 srelgot = bfd_get_section_by_name (dynobj, srelgot_name);
1406 BFD_ASSERT (srelgot != NULL);
1407
1408 outrel.r_offset = (sgot->output_section->vma
1409 + sgot->output_offset
1410 + off);
1411 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1412 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1413 (((Elf32_External_Rel *)
1414 srelgot->contents)
1415 + srelgot->reloc_count));
1416 ++srelgot->reloc_count;
1417 }
1418
1419 local_got_offsets[r_symndx] |= 1;
1420 }
1421
1422 relocation = sgot->output_offset + off;
1423 }
1424
1425 break;
1426
1427 case R_386_GOTOFF:
1428 /* Relocation is relative to the start of the global offset
1429 table. */
1430
1431 if (sgot == NULL)
1432 {
1433 sgot = bfd_get_section_by_name (dynobj, ".got");
1434 BFD_ASSERT (sgot != NULL);
1435 }
1436
1437 /* Note that sgot->output_offset is not involved in this
1438 calculation. We always want the start of .got. If we
1439 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1440 permitted by the ABI, we might have to change this
1441 calculation. */
1442 relocation -= sgot->output_section->vma;
1443
1444 break;
1445
1446 case R_386_GOTPC:
1447 /* Use global offset table as symbol value. */
1448
1449 if (sgot == NULL)
1450 {
1451 sgot = bfd_get_section_by_name (dynobj, ".got");
1452 BFD_ASSERT (sgot != NULL);
1453 }
1454
1455 relocation = sgot->output_section->vma;
1456
1457 break;
1458
1459 case R_386_PLT32:
1460 /* Relocation is to the entry for this symbol in the
1461 procedure linkage table. */
1462
1463 /* Resolve a PLT32 reloc again a local symbol directly,
1464 without using the procedure linkage table. */
1465 if (h == NULL)
1466 break;
1467
1468 if (h->plt.offset == (bfd_vma) -1)
1469 {
1470 /* We didn't make a PLT entry for this symbol. This
1471 happens when statically linking PIC code, or when
1472 using -Bsymbolic. */
1473 break;
1474 }
1475
1476 if (splt == NULL)
1477 {
1478 splt = bfd_get_section_by_name (dynobj, ".plt");
1479 BFD_ASSERT (splt != NULL);
1480 }
1481
1482 relocation = (splt->output_section->vma
1483 + splt->output_offset
1484 + h->plt.offset);
1485
1486 break;
1487
1488 case R_386_32:
1489 case R_386_PC32:
1490 if (info->shared
1491 && (input_section->flags & SEC_ALLOC) != 0
1492 && (r_type != R_386_PC32
1493 || (h != NULL
1494 && h->dynindx != -1
1495 && (! info->symbolic
1496 || (h->elf_link_hash_flags
1497 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1498 {
1499 Elf_Internal_Rel outrel;
1500 boolean skip, relocate;
1501
1502 /* When generating a shared object, these relocations
1503 are copied into the output file to be resolved at run
1504 time. */
1505
1506 if (sreloc == NULL)
1507 {
1508 const char *name;
1509
1510 name = (bfd_elf_string_from_elf_section
1511 (input_bfd,
1512 elf_elfheader (input_bfd)->e_shstrndx,
1513 elf_section_data (input_section)->rel_hdr.sh_name));
1514 if (name == NULL)
1515 return false;
1516
1517 if (info->combine_reloc)
1518 name = ".gnu.reloc";
1519
1520 BFD_ASSERT ((strncmp (name, ".rel", 4) == 0
1521 && strcmp (bfd_get_section_name (input_bfd,
1522 input_section),
1523 name + 4) == 0)
1524 || strcmp (name, ".gnu.reloc") == 0);
1525
1526 sreloc = bfd_get_section_by_name (dynobj, name);
1527 BFD_ASSERT (sreloc != NULL);
1528 }
1529
1530 skip = false;
1531
1532 if (elf_section_data (input_section)->stab_info == NULL)
1533 outrel.r_offset = rel->r_offset;
1534 else
1535 {
1536 bfd_vma off;
1537
1538 off = (_bfd_stab_section_offset
1539 (output_bfd, &elf_hash_table (info)->stab_info,
1540 input_section,
1541 &elf_section_data (input_section)->stab_info,
1542 rel->r_offset));
1543 if (off == (bfd_vma) -1)
1544 skip = true;
1545 outrel.r_offset = off;
1546 }
1547
1548 outrel.r_offset += (input_section->output_section->vma
1549 + input_section->output_offset);
1550
1551 if (skip)
1552 {
1553 memset (&outrel, 0, sizeof outrel);
1554 relocate = false;
1555 }
1556 else if (r_type == R_386_PC32)
1557 {
1558 BFD_ASSERT (h != NULL && h->dynindx != -1);
1559 relocate = false;
1560 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1561 }
1562 else
1563 {
1564 /* h->dynindx may be -1 if this symbol was marked to
1565 become local. */
1566 if (h == NULL
1567 || ((info->symbolic || h->dynindx == -1)
1568 && (h->elf_link_hash_flags
1569 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1570 {
1571 relocate = true;
1572 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1573 }
1574 else
1575 {
1576 BFD_ASSERT (h->dynindx != -1);
1577 relocate = false;
1578 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1579 }
1580 }
1581
1582 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1583 (((Elf32_External_Rel *)
1584 sreloc->contents)
1585 + sreloc->reloc_count));
1586 ++sreloc->reloc_count;
1587
1588 /* If this reloc is against an external symbol, we do
1589 not want to fiddle with the addend. Otherwise, we
1590 need to include the symbol value so that it becomes
1591 an addend for the dynamic reloc. */
1592 if (! relocate)
1593 continue;
1594 }
1595
1596 break;
1597
1598 default:
1599 break;
1600 }
1601
1602 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1603 contents, rel->r_offset,
1604 relocation, (bfd_vma) 0);
1605
1606 if (r != bfd_reloc_ok)
1607 {
1608 switch (r)
1609 {
1610 default:
1611 case bfd_reloc_outofrange:
1612 abort ();
1613 case bfd_reloc_overflow:
1614 {
1615 const char *name;
1616
1617 if (h != NULL)
1618 name = h->root.root.string;
1619 else
1620 {
1621 name = bfd_elf_string_from_elf_section (input_bfd,
1622 symtab_hdr->sh_link,
1623 sym->st_name);
1624 if (name == NULL)
1625 return false;
1626 if (*name == '\0')
1627 name = bfd_section_name (input_bfd, sec);
1628 }
1629 if (! ((*info->callbacks->reloc_overflow)
1630 (info, name, howto->name, (bfd_vma) 0,
1631 input_bfd, input_section, rel->r_offset)))
1632 return false;
1633 }
1634 break;
1635 }
1636 }
1637 }
1638
1639 return true;
1640 }
1641
1642 /* Finish up dynamic symbol handling. We set the contents of various
1643 dynamic sections here. */
1644
1645 static boolean
1646 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1647 bfd *output_bfd;
1648 struct bfd_link_info *info;
1649 struct elf_link_hash_entry *h;
1650 Elf_Internal_Sym *sym;
1651 {
1652 bfd *dynobj;
1653
1654 dynobj = elf_hash_table (info)->dynobj;
1655
1656 if (h->plt.offset != (bfd_vma) -1)
1657 {
1658 asection *splt;
1659 asection *sgot;
1660 asection *srel;
1661 bfd_vma plt_index;
1662 bfd_vma got_offset;
1663 Elf_Internal_Rel rel;
1664
1665 /* This symbol has an entry in the procedure linkage table. Set
1666 it up. */
1667
1668 BFD_ASSERT (h->dynindx != -1);
1669
1670 splt = bfd_get_section_by_name (dynobj, ".plt");
1671 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1672 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1673 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1674
1675 /* Get the index in the procedure linkage table which
1676 corresponds to this symbol. This is the index of this symbol
1677 in all the symbols for which we are making plt entries. The
1678 first entry in the procedure linkage table is reserved. */
1679 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1680
1681 /* Get the offset into the .got table of the entry that
1682 corresponds to this function. Each .got entry is 4 bytes.
1683 The first three are reserved. */
1684 got_offset = (plt_index + 3) * 4;
1685
1686 /* Fill in the entry in the procedure linkage table. */
1687 if (! info->shared)
1688 {
1689 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1690 PLT_ENTRY_SIZE);
1691 bfd_put_32 (output_bfd,
1692 (sgot->output_section->vma
1693 + sgot->output_offset
1694 + got_offset),
1695 splt->contents + h->plt.offset + 2);
1696 }
1697 else
1698 {
1699 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1700 PLT_ENTRY_SIZE);
1701 bfd_put_32 (output_bfd, got_offset,
1702 splt->contents + h->plt.offset + 2);
1703 }
1704
1705 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1706 splt->contents + h->plt.offset + 7);
1707 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1708 splt->contents + h->plt.offset + 12);
1709
1710 /* Fill in the entry in the global offset table. */
1711 bfd_put_32 (output_bfd,
1712 (splt->output_section->vma
1713 + splt->output_offset
1714 + h->plt.offset
1715 + 6),
1716 sgot->contents + got_offset);
1717
1718 /* Fill in the entry in the .rel.plt section. */
1719 rel.r_offset = (sgot->output_section->vma
1720 + sgot->output_offset
1721 + got_offset);
1722 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1723 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1724 ((Elf32_External_Rel *) srel->contents
1725 + plt_index));
1726
1727 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1728 {
1729 /* Mark the symbol as undefined, rather than as defined in
1730 the .plt section. Leave the value alone. */
1731 sym->st_shndx = SHN_UNDEF;
1732 }
1733 }
1734
1735 if (h->got.offset != (bfd_vma) -1)
1736 {
1737 asection *sgot;
1738 asection *srel;
1739 Elf_Internal_Rel rel;
1740 const char *srel_name = info->combine_reloc ? ".gnu.reloc" : ".rel.got";
1741
1742 /* This symbol has an entry in the global offset table. Set it
1743 up. */
1744
1745 sgot = bfd_get_section_by_name (dynobj, ".got");
1746 srel = bfd_get_section_by_name (dynobj, srel_name);
1747 BFD_ASSERT (sgot != NULL && srel != NULL);
1748
1749 rel.r_offset = (sgot->output_section->vma
1750 + sgot->output_offset
1751 + (h->got.offset &~ 1));
1752
1753 /* If this is a -Bsymbolic link, and the symbol is defined
1754 locally, we just want to emit a RELATIVE reloc. Likewise if
1755 the symbol was forced to be local because of a version file.
1756 The entry in the global offset table will already have been
1757 initialized in the relocate_section function. */
1758 if (info->shared
1759 && (info->symbolic || h->dynindx == -1)
1760 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1761 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1762 else
1763 {
1764 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1765 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1766 }
1767
1768 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1769 ((Elf32_External_Rel *) srel->contents
1770 + srel->reloc_count));
1771 ++srel->reloc_count;
1772 }
1773
1774 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1775 {
1776 asection *s;
1777 Elf_Internal_Rel rel;
1778 const char *s_name = info->combine_reloc ? ".gnu.reloc" : ".rel.bss";
1779
1780 /* This symbol needs a copy reloc. Set it up. */
1781
1782 BFD_ASSERT (h->dynindx != -1
1783 && (h->root.type == bfd_link_hash_defined
1784 || h->root.type == bfd_link_hash_defweak));
1785
1786 s = bfd_get_section_by_name (h->root.u.def.section->owner, s_name);
1787 BFD_ASSERT (s != NULL);
1788
1789 rel.r_offset = (h->root.u.def.value
1790 + h->root.u.def.section->output_section->vma
1791 + h->root.u.def.section->output_offset);
1792 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1793 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1794 ((Elf32_External_Rel *) s->contents
1795 + s->reloc_count));
1796 ++s->reloc_count;
1797 }
1798
1799 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1800 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1801 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1802 sym->st_shndx = SHN_ABS;
1803
1804 return true;
1805 }
1806
1807 /* Finish up the dynamic sections. */
1808
1809 static boolean
1810 elf_i386_finish_dynamic_sections (output_bfd, info)
1811 bfd *output_bfd;
1812 struct bfd_link_info *info;
1813 {
1814 bfd *dynobj;
1815 asection *sgot;
1816 asection *sdyn;
1817
1818 dynobj = elf_hash_table (info)->dynobj;
1819
1820 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1821 BFD_ASSERT (sgot != NULL);
1822 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1823
1824 if (elf_hash_table (info)->dynamic_sections_created)
1825 {
1826 asection *splt;
1827 Elf32_External_Dyn *dyncon, *dynconend;
1828
1829 splt = bfd_get_section_by_name (dynobj, ".plt");
1830 BFD_ASSERT (splt != NULL && sdyn != NULL);
1831
1832 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1833 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1834 for (; dyncon < dynconend; dyncon++)
1835 {
1836 Elf_Internal_Dyn dyn;
1837 const char *name;
1838 asection *s;
1839
1840 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1841
1842 switch (dyn.d_tag)
1843 {
1844 default:
1845 break;
1846
1847 case DT_PLTGOT:
1848 name = ".got";
1849 goto get_vma;
1850 case DT_JMPREL:
1851 name = ".rel.plt";
1852 get_vma:
1853 s = bfd_get_section_by_name (output_bfd, name);
1854 BFD_ASSERT (s != NULL);
1855 dyn.d_un.d_ptr = s->vma;
1856 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1857 break;
1858
1859 case DT_PLTRELSZ:
1860 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1861 BFD_ASSERT (s != NULL);
1862 if (s->_cooked_size != 0)
1863 dyn.d_un.d_val = s->_cooked_size;
1864 else
1865 dyn.d_un.d_val = s->_raw_size;
1866 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1867 break;
1868
1869 case DT_RELSZ:
1870 /* My reading of the SVR4 ABI indicates that the
1871 procedure linkage table relocs (DT_JMPREL) should be
1872 included in the overall relocs (DT_REL). This is
1873 what Solaris does. However, UnixWare can not handle
1874 that case. Therefore, we override the DT_RELSZ entry
1875 here to make it not include the JMPREL relocs. Since
1876 the linker script arranges for .rel.plt to follow all
1877 other relocation sections, we don't have to worry
1878 about changing the DT_REL entry. */
1879 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1880 if (s != NULL)
1881 {
1882 if (s->_cooked_size != 0)
1883 dyn.d_un.d_val -= s->_cooked_size;
1884 else
1885 dyn.d_un.d_val -= s->_raw_size;
1886 }
1887 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1888 break;
1889 }
1890 }
1891
1892 /* Fill in the first entry in the procedure linkage table. */
1893 if (splt->_raw_size > 0)
1894 {
1895 if (info->shared)
1896 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1897 else
1898 {
1899 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1900 bfd_put_32 (output_bfd,
1901 sgot->output_section->vma + sgot->output_offset + 4,
1902 splt->contents + 2);
1903 bfd_put_32 (output_bfd,
1904 sgot->output_section->vma + sgot->output_offset + 8,
1905 splt->contents + 8);
1906 }
1907 }
1908
1909 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1910 really seem like the right value. */
1911 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1912 }
1913
1914 /* Fill in the first three entries in the global offset table. */
1915 if (sgot->_raw_size > 0)
1916 {
1917 if (sdyn == NULL)
1918 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1919 else
1920 bfd_put_32 (output_bfd,
1921 sdyn->output_section->vma + sdyn->output_offset,
1922 sgot->contents);
1923 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1924 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1925 }
1926
1927 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1928
1929 return true;
1930 }
1931
1932 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1933 #define TARGET_LITTLE_NAME "elf32-i386"
1934 #define ELF_ARCH bfd_arch_i386
1935 #define ELF_MACHINE_CODE EM_386
1936 #define ELF_MAXPAGESIZE 0x1000
1937 #define elf_info_to_howto elf_i386_info_to_howto
1938 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1939 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1940 #define bfd_elf32_bfd_is_local_label_name \
1941 elf_i386_is_local_label_name
1942 #define elf_backend_create_dynamic_sections \
1943 _bfd_elf_create_dynamic_sections
1944 #define bfd_elf32_bfd_link_hash_table_create \
1945 elf_i386_link_hash_table_create
1946 #define elf_backend_check_relocs elf_i386_check_relocs
1947 #define elf_backend_adjust_dynamic_symbol \
1948 elf_i386_adjust_dynamic_symbol
1949 #define elf_backend_size_dynamic_sections \
1950 elf_i386_size_dynamic_sections
1951 #define elf_backend_relocate_section elf_i386_relocate_section
1952 #define elf_backend_finish_dynamic_symbol \
1953 elf_i386_finish_dynamic_symbol
1954 #define elf_backend_finish_dynamic_sections \
1955 elf_i386_finish_dynamic_sections
1956 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
1957 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
1958
1959 #define elf_backend_can_gc_sections 1
1960 #define elf_backend_want_got_plt 1
1961 #define elf_backend_plt_readonly 1
1962 #define elf_backend_want_plt_sym 0
1963 #define elf_backend_got_header_size 12
1964 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
1965
1966 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.