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