1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 static reloc_howto_type
*elf_i386_reloc_type_lookup
28 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
29 static void elf_i386_info_to_howto
30 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
31 static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
33 static boolean elf_i386_is_local_label_name
PARAMS ((bfd
*, const char *));
34 static struct bfd_hash_entry
*elf_i386_link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
36 static struct bfd_link_hash_table
*elf_i386_link_hash_table_create
38 static boolean create_got_section
PARAMS((bfd
*, struct bfd_link_info
*));
39 static boolean elf_i386_create_dynamic_sections
40 PARAMS((bfd
*, struct bfd_link_info
*));
41 static boolean elf_i386_check_relocs
42 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
43 const Elf_Internal_Rela
*));
44 static asection
*elf_i386_gc_mark_hook
45 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
46 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
47 static boolean elf_i386_gc_sweep_hook
48 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
49 const Elf_Internal_Rela
*));
50 static boolean elf_i386_adjust_dynamic_symbol
51 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
52 static boolean allocate_plt_and_got_and_discard_relocs
53 PARAMS ((struct elf_link_hash_entry
*, PTR
));
54 static boolean elf_i386_size_dynamic_sections
55 PARAMS ((bfd
*, struct bfd_link_info
*));
56 static boolean elf_i386_relocate_section
57 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
58 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
59 static boolean elf_i386_finish_dynamic_symbol
60 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
62 static boolean elf_i386_finish_dynamic_sections
63 PARAMS ((bfd
*, struct bfd_link_info
*));
64 static boolean elf_i386_fake_sections
65 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, asection
*));
66 static enum elf_reloc_type_class elf_i386_reloc_type_class
PARAMS ((int));
67 static boolean elf_i386_grok_prstatus
68 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
69 static boolean elf_i386_grok_psinfo
70 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
72 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
76 static reloc_howto_type elf_howto_table
[]=
78 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
79 bfd_elf_generic_reloc
, "R_386_NONE",
80 true, 0x00000000, 0x00000000, false),
81 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
82 bfd_elf_generic_reloc
, "R_386_32",
83 true, 0xffffffff, 0xffffffff, false),
84 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
85 bfd_elf_generic_reloc
, "R_386_PC32",
86 true, 0xffffffff, 0xffffffff, true),
87 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
88 bfd_elf_generic_reloc
, "R_386_GOT32",
89 true, 0xffffffff, 0xffffffff, false),
90 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
91 bfd_elf_generic_reloc
, "R_386_PLT32",
92 true, 0xffffffff, 0xffffffff, true),
93 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
94 bfd_elf_generic_reloc
, "R_386_COPY",
95 true, 0xffffffff, 0xffffffff, false),
96 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
98 true, 0xffffffff, 0xffffffff, false),
99 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
100 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
101 true, 0xffffffff, 0xffffffff, false),
102 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_386_RELATIVE",
104 true, 0xffffffff, 0xffffffff, false),
105 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_386_GOTOFF",
107 true, 0xffffffff, 0xffffffff, false),
108 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_386_GOTPC",
110 true, 0xffffffff, 0xffffffff, true),
112 /* We have a gap in the reloc numbers here.
113 R_386_standard counts the number up to this point, and
114 R_386_ext_offset is the value to subtract from a reloc type of
115 R_386_16 thru R_386_PC8 to form an index into this table. */
116 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
117 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
119 /* The remaining relocs are a GNU extension. */
120 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_16",
122 true, 0xffff, 0xffff, false),
123 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_PC16",
125 true, 0xffff, 0xffff, true),
126 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_8",
128 true, 0xff, 0xff, false),
129 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
130 bfd_elf_generic_reloc
, "R_386_PC8",
131 true, 0xff, 0xff, true),
134 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
135 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
137 /* GNU extension to record C++ vtable hierarchy. */
138 HOWTO (R_386_GNU_VTINHERIT
, /* type */
140 2, /* size (0 = byte, 1 = short, 2 = long) */
142 false, /* pc_relative */
144 complain_overflow_dont
, /* complain_on_overflow */
145 NULL
, /* special_function */
146 "R_386_GNU_VTINHERIT", /* name */
147 false, /* partial_inplace */
152 /* GNU extension to record C++ vtable member usage. */
153 HOWTO (R_386_GNU_VTENTRY
, /* type */
155 2, /* size (0 = byte, 1 = short, 2 = long) */
157 false, /* pc_relative */
159 complain_overflow_dont
, /* complain_on_overflow */
160 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
161 "R_386_GNU_VTENTRY", /* name */
162 false, /* partial_inplace */
167 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
171 #ifdef DEBUG_GEN_RELOC
172 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
177 static reloc_howto_type
*
178 elf_i386_reloc_type_lookup (abfd
, code
)
179 bfd
*abfd ATTRIBUTE_UNUSED
;
180 bfd_reloc_code_real_type code
;
185 TRACE ("BFD_RELOC_NONE");
186 return &elf_howto_table
[(unsigned int) R_386_NONE
];
189 TRACE ("BFD_RELOC_32");
190 return &elf_howto_table
[(unsigned int) R_386_32
];
193 TRACE ("BFD_RELOC_CTOR");
194 return &elf_howto_table
[(unsigned int) R_386_32
];
196 case BFD_RELOC_32_PCREL
:
197 TRACE ("BFD_RELOC_PC32");
198 return &elf_howto_table
[(unsigned int) R_386_PC32
];
200 case BFD_RELOC_386_GOT32
:
201 TRACE ("BFD_RELOC_386_GOT32");
202 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
204 case BFD_RELOC_386_PLT32
:
205 TRACE ("BFD_RELOC_386_PLT32");
206 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
208 case BFD_RELOC_386_COPY
:
209 TRACE ("BFD_RELOC_386_COPY");
210 return &elf_howto_table
[(unsigned int) R_386_COPY
];
212 case BFD_RELOC_386_GLOB_DAT
:
213 TRACE ("BFD_RELOC_386_GLOB_DAT");
214 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
216 case BFD_RELOC_386_JUMP_SLOT
:
217 TRACE ("BFD_RELOC_386_JUMP_SLOT");
218 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
220 case BFD_RELOC_386_RELATIVE
:
221 TRACE ("BFD_RELOC_386_RELATIVE");
222 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
224 case BFD_RELOC_386_GOTOFF
:
225 TRACE ("BFD_RELOC_386_GOTOFF");
226 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
228 case BFD_RELOC_386_GOTPC
:
229 TRACE ("BFD_RELOC_386_GOTPC");
230 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
232 /* The remaining relocs are a GNU extension. */
234 TRACE ("BFD_RELOC_16");
235 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
237 case BFD_RELOC_16_PCREL
:
238 TRACE ("BFD_RELOC_16_PCREL");
239 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
242 TRACE ("BFD_RELOC_8");
243 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
245 case BFD_RELOC_8_PCREL
:
246 TRACE ("BFD_RELOC_8_PCREL");
247 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
249 case BFD_RELOC_VTABLE_INHERIT
:
250 TRACE ("BFD_RELOC_VTABLE_INHERIT");
251 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
254 case BFD_RELOC_VTABLE_ENTRY
:
255 TRACE ("BFD_RELOC_VTABLE_ENTRY");
256 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
268 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
269 bfd
*abfd ATTRIBUTE_UNUSED
;
270 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
271 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
277 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
278 bfd
*abfd ATTRIBUTE_UNUSED
;
280 Elf32_Internal_Rel
*dst
;
282 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
285 if ((indx
= r_type
) >= R_386_standard
286 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
287 >= R_386_ext
- R_386_standard
)
288 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
289 >= R_386_vt
- R_386_ext
))
291 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
292 bfd_archive_filename (abfd
), (int) r_type
);
293 indx
= (unsigned int) R_386_NONE
;
295 cache_ptr
->howto
= &elf_howto_table
[indx
];
298 /* Return whether a symbol name implies a local label. The UnixWare
299 2.1 cc generates temporary symbols that start with .X, so we
300 recognize them here. FIXME: do other SVR4 compilers also use .X?.
301 If so, we should move the .X recognition into
302 _bfd_elf_is_local_label_name. */
305 elf_i386_is_local_label_name (abfd
, name
)
309 if (name
[0] == '.' && name
[1] == 'X')
312 return _bfd_elf_is_local_label_name (abfd
, name
);
315 /* Functions for the i386 ELF linker. */
317 /* The name of the dynamic interpreter. This is put in the .interp
320 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
322 /* The size in bytes of an entry in the procedure linkage table. */
324 #define PLT_ENTRY_SIZE 16
326 /* The first entry in an absolute procedure linkage table looks like
327 this. See the SVR4 ABI i386 supplement to see how this works. */
329 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
331 0xff, 0x35, /* pushl contents of address */
332 0, 0, 0, 0, /* replaced with address of .got + 4. */
333 0xff, 0x25, /* jmp indirect */
334 0, 0, 0, 0, /* replaced with address of .got + 8. */
335 0, 0, 0, 0 /* pad out to 16 bytes. */
338 /* Subsequent entries in an absolute procedure linkage table look like
341 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
343 0xff, 0x25, /* jmp indirect */
344 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
345 0x68, /* pushl immediate */
346 0, 0, 0, 0, /* replaced with offset into relocation table. */
347 0xe9, /* jmp relative */
348 0, 0, 0, 0 /* replaced with offset to start of .plt. */
351 /* The first entry in a PIC procedure linkage table look like this. */
353 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
355 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
356 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
357 0, 0, 0, 0 /* pad out to 16 bytes. */
360 /* Subsequent entries in a PIC procedure linkage table look like this. */
362 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
364 0xff, 0xa3, /* jmp *offset(%ebx) */
365 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
366 0x68, /* pushl immediate */
367 0, 0, 0, 0, /* replaced with offset into relocation table. */
368 0xe9, /* jmp relative */
369 0, 0, 0, 0 /* replaced with offset to start of .plt. */
372 /* The i386 linker needs to keep track of the number of relocs that it
373 decides to copy as dynamic relocs in check_relocs for each symbol.
374 This is so that it can later discard them if they are found to be
375 unnecessary. We store the information in a field extending the
376 regular ELF linker hash table. */
378 struct elf_i386_dyn_relocs
381 struct elf_i386_dyn_relocs
*next
;
382 /* A section in dynobj. */
384 /* Number of relocs copied in this section. */
388 /* i386 ELF linker hash entry. */
390 struct elf_i386_link_hash_entry
392 struct elf_link_hash_entry root
;
394 /* Number of PC relative relocs copied for this symbol. */
395 struct elf_i386_dyn_relocs
*dyn_relocs
;
398 /* i386 ELF linker hash table. */
400 struct elf_i386_link_hash_table
402 struct elf_link_hash_table root
;
404 /* Short-cuts to get to dynamic linker sections. */
414 /* Get the i386 ELF linker hash table from a link_info structure. */
416 #define elf_i386_hash_table(p) \
417 ((struct elf_i386_link_hash_table *) ((p)->hash))
419 /* Create an entry in an i386 ELF linker hash table. */
421 static struct bfd_hash_entry
*
422 elf_i386_link_hash_newfunc (entry
, table
, string
)
423 struct bfd_hash_entry
*entry
;
424 struct bfd_hash_table
*table
;
427 struct elf_i386_link_hash_entry
*ret
=
428 (struct elf_i386_link_hash_entry
*) entry
;
430 /* Allocate the structure if it has not already been allocated by a
432 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
433 ret
= ((struct elf_i386_link_hash_entry
*)
434 bfd_hash_allocate (table
,
435 sizeof (struct elf_i386_link_hash_entry
)));
436 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
437 return (struct bfd_hash_entry
*) ret
;
439 /* Call the allocation method of the superclass. */
440 ret
= ((struct elf_i386_link_hash_entry
*)
441 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
443 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
445 ret
->dyn_relocs
= NULL
;
448 return (struct bfd_hash_entry
*) ret
;
451 /* Create an i386 ELF linker hash table. */
453 static struct bfd_link_hash_table
*
454 elf_i386_link_hash_table_create (abfd
)
457 struct elf_i386_link_hash_table
*ret
;
458 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
460 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
461 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
464 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
465 elf_i386_link_hash_newfunc
))
467 bfd_release (abfd
, ret
);
479 return &ret
->root
.root
;
482 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
483 shortcuts to them in our hash table. */
486 create_got_section (dynobj
, info
)
488 struct bfd_link_info
*info
;
490 struct elf_i386_link_hash_table
*htab
;
492 if (! _bfd_elf_create_got_section (dynobj
, info
))
495 htab
= elf_i386_hash_table (info
);
496 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
497 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
498 if (!htab
->sgot
|| !htab
->sgotplt
)
501 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
502 if (htab
->srelgot
== NULL
503 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
504 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
505 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
507 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
512 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
513 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
517 elf_i386_create_dynamic_sections (dynobj
, info
)
519 struct bfd_link_info
*info
;
521 struct elf_i386_link_hash_table
*htab
;
523 htab
= elf_i386_hash_table (info
);
524 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
527 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
530 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
531 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
532 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
534 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
536 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
537 || (!info
->shared
&& !htab
->srelbss
))
543 /* Look through the relocs for a section during the first phase, and
544 allocate space in the global offset table or procedure linkage
548 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
550 struct bfd_link_info
*info
;
552 const Elf_Internal_Rela
*relocs
;
554 struct elf_i386_link_hash_table
*htab
;
556 Elf_Internal_Shdr
*symtab_hdr
;
557 struct elf_link_hash_entry
**sym_hashes
;
558 bfd_signed_vma
*local_got_refcounts
;
559 const Elf_Internal_Rela
*rel
;
560 const Elf_Internal_Rela
*rel_end
;
563 if (info
->relocateable
)
566 htab
= elf_i386_hash_table (info
);
567 dynobj
= htab
->root
.dynobj
;
568 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
569 sym_hashes
= elf_sym_hashes (abfd
);
570 local_got_refcounts
= elf_local_got_refcounts (abfd
);
574 rel_end
= relocs
+ sec
->reloc_count
;
575 for (rel
= relocs
; rel
< rel_end
; rel
++)
577 unsigned long r_symndx
;
578 struct elf_link_hash_entry
*h
;
580 r_symndx
= ELF32_R_SYM (rel
->r_info
);
582 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
584 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
585 bfd_archive_filename (abfd
),
590 if (r_symndx
< symtab_hdr
->sh_info
)
593 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
595 /* Some relocs require a global offset table. */
596 if (htab
->sgot
== NULL
)
598 switch (ELF32_R_TYPE (rel
->r_info
))
604 htab
->root
.dynobj
= dynobj
= abfd
;
605 if (!create_got_section (dynobj
, info
))
614 switch (ELF32_R_TYPE (rel
->r_info
))
617 /* This symbol requires a global offset table entry. */
620 if (h
->got
.refcount
== -1)
623 h
->got
.refcount
+= 1;
627 /* This is a global offset table entry for a local symbol. */
628 if (local_got_refcounts
== NULL
)
632 size
= symtab_hdr
->sh_info
;
633 size
*= sizeof (bfd_signed_vma
);
634 local_got_refcounts
= ((bfd_signed_vma
*)
635 bfd_alloc (abfd
, size
));
636 if (local_got_refcounts
== NULL
)
638 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
639 memset (local_got_refcounts
, -1, (size_t) size
);
641 if (local_got_refcounts
[r_symndx
] == -1)
642 local_got_refcounts
[r_symndx
] = 1;
644 local_got_refcounts
[r_symndx
] += 1;
649 /* This symbol requires a procedure linkage table entry. We
650 actually build the entry in adjust_dynamic_symbol,
651 because this might be a case of linking PIC code which is
652 never referenced by a dynamic object, in which case we
653 don't need to generate a procedure linkage table entry
656 /* If this is a local symbol, we resolve it directly without
657 creating a procedure linkage table entry. */
661 if (h
->plt
.refcount
== -1)
663 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
667 h
->plt
.refcount
+= 1;
672 if (h
!= NULL
&& !info
->shared
)
674 /* If this reloc is in a read-only section, we might
675 need a copy reloc. */
676 if ((sec
->flags
& SEC_READONLY
) != 0)
677 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
679 /* We may need a .plt entry if the function this reloc
680 refers to is in a shared lib. */
681 if (h
->plt
.refcount
== -1)
684 h
->plt
.refcount
+= 1;
687 /* If we are creating a shared library, and this is a reloc
688 against a global symbol, or a non PC relative reloc
689 against a local symbol, then we need to copy the reloc
690 into the shared library. However, if we are linking with
691 -Bsymbolic, we do not need to copy a reloc against a
692 global symbol which is defined in an object we are
693 including in the link (i.e., DEF_REGULAR is set). At
694 this point we have not seen all the input files, so it is
695 possible that DEF_REGULAR is not set now but will be set
696 later (it is never cleared). In case of a weak definition,
697 DEF_REGULAR may be cleared later by a strong definition in
698 a shared library. We account for that possibility below by
699 storing information in the relocs_copied field of the hash
700 table entry. A similar situation occurs when creating
701 shared libraries and symbol visibility changes render the
704 If on the other hand, we are creating an executable, we
705 may need to keep relocations for symbols satisfied by a
706 dynamic library if we manage to avoid copy relocs for the
709 && (sec
->flags
& SEC_ALLOC
) != 0
710 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
713 || h
->root
.type
== bfd_link_hash_defweak
714 || (h
->elf_link_hash_flags
715 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
717 && (sec
->flags
& SEC_ALLOC
) != 0
719 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
720 && (h
->root
.type
== bfd_link_hash_defweak
721 || (h
->elf_link_hash_flags
722 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
724 /* We must copy these reloc types into the output file.
725 Create a reloc section in dynobj and make room for
728 htab
->root
.dynobj
= dynobj
= abfd
;
734 name
= (bfd_elf_string_from_elf_section
736 elf_elfheader (abfd
)->e_shstrndx
,
737 elf_section_data (sec
)->rel_hdr
.sh_name
));
741 if (strncmp (name
, ".rel", 4) != 0
742 || strcmp (bfd_get_section_name (abfd
, sec
),
745 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
746 bfd_archive_filename (abfd
),
750 sreloc
= bfd_get_section_by_name (dynobj
, name
);
755 sreloc
= bfd_make_section (dynobj
, name
);
756 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
757 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
758 if ((sec
->flags
& SEC_ALLOC
) != 0)
759 flags
|= SEC_ALLOC
| SEC_LOAD
;
761 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
762 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
765 if (sec
->flags
& SEC_READONLY
)
766 info
->flags
|= DF_TEXTREL
;
769 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
771 /* If this is a global symbol, we count the number of PC
772 relative relocations we have entered for this symbol,
773 so that we can discard them later as necessary. Note
774 that this function is only called if we are using an
775 elf_i386 linker hash table, which means that h is
776 really a pointer to an elf_i386_link_hash_entry. */
779 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
))
781 struct elf_i386_link_hash_entry
*eh
;
782 struct elf_i386_dyn_relocs
*p
;
784 eh
= (struct elf_i386_link_hash_entry
*) h
;
786 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
787 if (p
->section
== sreloc
)
792 p
= ((struct elf_i386_dyn_relocs
*)
793 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
796 p
->next
= eh
->dyn_relocs
;
808 /* This relocation describes the C++ object vtable hierarchy.
809 Reconstruct it for later use during GC. */
810 case R_386_GNU_VTINHERIT
:
811 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
815 /* This relocation describes which C++ vtable entries are actually
816 used. Record for later use during GC. */
817 case R_386_GNU_VTENTRY
:
818 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
830 /* Return the section that should be marked against GC for a given
834 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
836 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
837 Elf_Internal_Rela
*rel
;
838 struct elf_link_hash_entry
*h
;
839 Elf_Internal_Sym
*sym
;
843 switch (ELF32_R_TYPE (rel
->r_info
))
845 case R_386_GNU_VTINHERIT
:
846 case R_386_GNU_VTENTRY
:
850 switch (h
->root
.type
)
852 case bfd_link_hash_defined
:
853 case bfd_link_hash_defweak
:
854 return h
->root
.u
.def
.section
;
856 case bfd_link_hash_common
:
857 return h
->root
.u
.c
.p
->section
;
866 if (!(elf_bad_symtab (abfd
)
867 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
868 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
869 && sym
->st_shndx
!= SHN_COMMON
))
871 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
878 /* Update the got entry reference counts for the section being removed. */
881 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
883 struct bfd_link_info
*info
;
885 const Elf_Internal_Rela
*relocs
;
887 Elf_Internal_Shdr
*symtab_hdr
;
888 struct elf_link_hash_entry
**sym_hashes
;
889 bfd_signed_vma
*local_got_refcounts
;
890 const Elf_Internal_Rela
*rel
, *relend
;
891 unsigned long r_symndx
;
892 struct elf_link_hash_entry
*h
;
895 dynobj
= elf_hash_table (info
)->dynobj
;
899 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
900 sym_hashes
= elf_sym_hashes (abfd
);
901 local_got_refcounts
= elf_local_got_refcounts (abfd
);
903 relend
= relocs
+ sec
->reloc_count
;
904 for (rel
= relocs
; rel
< relend
; rel
++)
905 switch (ELF32_R_TYPE (rel
->r_info
))
910 r_symndx
= ELF32_R_SYM (rel
->r_info
);
911 if (r_symndx
>= symtab_hdr
->sh_info
)
913 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
914 if (h
->got
.refcount
> 0)
915 h
->got
.refcount
-= 1;
917 else if (local_got_refcounts
!= NULL
)
919 if (local_got_refcounts
[r_symndx
] > 0)
920 local_got_refcounts
[r_symndx
] -= 1;
931 r_symndx
= ELF32_R_SYM (rel
->r_info
);
932 if (r_symndx
>= symtab_hdr
->sh_info
)
934 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
935 if (h
->plt
.refcount
> 0)
936 h
->plt
.refcount
-= 1;
947 /* Adjust a symbol defined by a dynamic object and referenced by a
948 regular object. The current definition is in some section of the
949 dynamic object, but we're not including those sections. We have to
950 change the definition to something the rest of the link can
954 elf_i386_adjust_dynamic_symbol (info
, h
)
955 struct bfd_link_info
*info
;
956 struct elf_link_hash_entry
*h
;
958 struct elf_i386_link_hash_table
*htab
;
961 unsigned int power_of_two
;
963 htab
= elf_i386_hash_table (info
);
964 dynobj
= htab
->root
.dynobj
;
966 /* If this is a function, put it in the procedure linkage table. We
967 will fill in the contents of the procedure linkage table later,
968 when we know the address of the .got section. */
969 if (h
->type
== STT_FUNC
970 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
972 if (h
->plt
.refcount
<= 0
974 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
975 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
977 /* This case can occur if we saw a PLT32 reloc in an input
978 file, but the symbol was never referred to by a dynamic
979 object, or if all references were garbage collected. In
980 such a case, we don't actually need to build a procedure
981 linkage table, and we can just do a PC32 reloc instead. */
982 h
->plt
.refcount
= (bfd_vma
) -1;
983 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
989 /* It's possible that we incorrectly decided a .plt reloc was
990 needed for an R_386_PC32 reloc to a non-function sym in
991 check_relocs. We can't decide accurately between function and
992 non-function syms in check-relocs; Objects loaded later in
993 the link may change h->type. So fix it now. */
994 h
->plt
.refcount
= (bfd_vma
) -1;
996 /* If this is a weak symbol, and there is a real definition, the
997 processor independent code will have arranged for us to see the
998 real definition first, and we can just use the same value. */
999 if (h
->weakdef
!= NULL
)
1001 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1002 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1003 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1004 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1008 /* This is a reference to a symbol defined by a dynamic object which
1009 is not a function. */
1011 /* If we are creating a shared library, we must presume that the
1012 only references to the symbol are via the global offset table.
1013 For such cases we need not do anything here; the relocations will
1014 be handled correctly by relocate_section. */
1018 /* If there are no references to this symbol that do not use the
1019 GOT, we don't need to generate a copy reloc. */
1020 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1023 /* We must allocate the symbol in our .dynbss section, which will
1024 become part of the .bss section of the executable. There will be
1025 an entry for this symbol in the .dynsym section. The dynamic
1026 object will contain position independent code, so all references
1027 from the dynamic object to this symbol will go through the global
1028 offset table. The dynamic linker will use the .dynsym entry to
1029 determine the address it must put in the global offset table, so
1030 both the dynamic object and the regular object will refer to the
1031 same memory location for the variable. */
1037 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1038 copy the initial value out of the dynamic object and into the
1039 runtime process image. We need to remember the offset into the
1040 .rel.bss section we are going to use. */
1041 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1045 srel
= htab
->srelbss
;
1048 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1049 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1052 /* We need to figure out the alignment required for this symbol. I
1053 have no idea how ELF linkers handle this. */
1054 power_of_two
= bfd_log2 (h
->size
);
1055 if (power_of_two
> 3)
1058 /* Apply the required alignment. */
1059 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1060 (bfd_size_type
) (1 << power_of_two
));
1061 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1063 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1067 /* Define the symbol as being at this point in the section. */
1068 h
->root
.u
.def
.section
= s
;
1069 h
->root
.u
.def
.value
= s
->_raw_size
;
1071 /* Increment the section size to make room for the symbol. */
1072 s
->_raw_size
+= h
->size
;
1077 /* This is the condition under which elf_i386_finish_dynamic_symbol
1078 will be called from elflink.h. If elflink.h doesn't call our
1079 finish_dynamic_symbol routine, we'll need to do something about
1080 initializing any .plt and .got entries in elf_i386_relocate_section. */
1081 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1083 && ((INFO)->shared \
1084 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1085 && ((H)->dynindx != -1 \
1086 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1088 /* Allocate space in .plt, .got and associated reloc sections for
1089 global syms. Also discards space allocated for relocs in the
1090 check_relocs function that we subsequently have found to be
1094 allocate_plt_and_got_and_discard_relocs (h
, inf
)
1095 struct elf_link_hash_entry
*h
;
1098 struct bfd_link_info
*info
;
1099 struct elf_i386_link_hash_table
*htab
;
1101 struct elf_i386_link_hash_entry
*eh
;
1103 if (h
->root
.type
== bfd_link_hash_indirect
1104 || h
->root
.type
== bfd_link_hash_warning
)
1107 info
= (struct bfd_link_info
*) inf
;
1108 htab
= elf_i386_hash_table (info
);
1110 if (htab
->root
.dynamic_sections_created
1111 && h
->plt
.refcount
> 0)
1113 /* Make sure this symbol is output as a dynamic symbol.
1114 Undefined weak syms won't yet be marked as dynamic. */
1115 if (h
->dynindx
== -1
1116 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1118 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1126 /* If this is the first .plt entry, make room for the special
1128 if (s
->_raw_size
== 0)
1129 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1131 h
->plt
.offset
= s
->_raw_size
;
1133 /* If this symbol is not defined in a regular file, and we are
1134 not generating a shared library, then set the symbol to this
1135 location in the .plt. This is required to make function
1136 pointers compare as equal between the normal executable and
1137 the shared library. */
1139 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1141 h
->root
.u
.def
.section
= s
;
1142 h
->root
.u
.def
.value
= h
->plt
.offset
;
1145 /* Make room for this entry. */
1146 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1148 /* We also need to make an entry in the .got.plt section, which
1149 will be placed in the .got section by the linker script. */
1155 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1157 /* We also need to make an entry in the .rel.plt section. */
1161 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1166 h
->plt
.offset
= (bfd_vma
) -1;
1167 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1170 if (h
->got
.refcount
> 0)
1174 /* Make sure this symbol is output as a dynamic symbol.
1175 Undefined weak syms won't yet be marked as dynamic. */
1176 if (h
->dynindx
== -1
1177 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1179 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1184 h
->got
.offset
= s
->_raw_size
;
1186 dyn
= htab
->root
.dynamic_sections_created
;
1187 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1188 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1191 h
->got
.offset
= (bfd_vma
) -1;
1193 /* In the shared -Bsymbolic case, discard space allocated for
1194 dynamic relocs against symbols which turn out to be defined
1195 in regular objects. For the normal shared case, discard space
1196 for relocs that have become local due to symbol visibility
1197 changes. For the non-shared case, discard space for symbols
1198 which turn out to need copy relocs or are not dynamic. */
1200 eh
= (struct elf_i386_link_hash_entry
*) h
;
1201 if (eh
->dyn_relocs
== NULL
)
1205 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1206 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1207 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1208 || (htab
->root
.dynamic_sections_created
1209 && (h
->root
.type
== bfd_link_hash_undefweak
1210 || h
->root
.type
== bfd_link_hash_undefined
))))
1212 /* Make sure this symbol is output as a dynamic symbol.
1213 Undefined weak syms won't yet be marked as dynamic. */
1214 if (h
->dynindx
== -1
1215 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1217 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1221 /* If that succeeded, we know we'll be keeping all the relocs. */
1222 if (h
->dynindx
!= -1)
1227 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1228 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1229 || info
->symbolic
)))
1231 struct elf_i386_dyn_relocs
*c
;
1233 for (c
= eh
->dyn_relocs
; c
!= NULL
; c
= c
->next
)
1234 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1240 /* Set the sizes of the dynamic sections. */
1243 elf_i386_size_dynamic_sections (output_bfd
, info
)
1244 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1245 struct bfd_link_info
*info
;
1247 struct elf_i386_link_hash_table
*htab
;
1253 htab
= elf_i386_hash_table (info
);
1254 dynobj
= htab
->root
.dynobj
;
1258 if (htab
->root
.dynamic_sections_created
)
1260 /* Set the contents of the .interp section to the interpreter. */
1263 s
= bfd_get_section_by_name (dynobj
, ".interp");
1266 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1267 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1271 /* Set up .got offsets for local syms. */
1272 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1274 bfd_signed_vma
*local_got
;
1275 bfd_signed_vma
*end_local_got
;
1276 bfd_size_type locsymcount
;
1277 Elf_Internal_Shdr
*symtab_hdr
;
1280 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1283 local_got
= elf_local_got_refcounts (i
);
1287 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1288 locsymcount
= symtab_hdr
->sh_info
;
1289 end_local_got
= local_got
+ locsymcount
;
1291 srel
= htab
->srelgot
;
1292 for (; local_got
< end_local_got
; ++local_got
)
1296 *local_got
= s
->_raw_size
;
1299 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1302 *local_got
= (bfd_vma
) -1;
1306 /* Allocate global sym .plt and .got entries. Also discard all
1308 elf_link_hash_traverse (&htab
->root
,
1309 allocate_plt_and_got_and_discard_relocs
,
1312 /* We now have determined the sizes of the various dynamic sections.
1313 Allocate memory for them. */
1315 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1317 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1322 || s
== htab
->sgotplt
)
1324 /* Strip this section if we don't need it; see the
1327 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1329 if (s
->_raw_size
== 0)
1331 /* If we don't need this section, strip it from the
1332 output file. This is mostly to handle .rel.bss and
1333 .rel.plt. We must create both sections in
1334 create_dynamic_sections, because they must be created
1335 before the linker maps input sections to output
1336 sections. The linker does that before
1337 adjust_dynamic_symbol is called, and it is that
1338 function which decides whether anything needs to go
1339 into these sections. */
1343 if (s
!= htab
->srelplt
)
1346 /* We use the reloc_count field as a counter if we need
1347 to copy relocs into the output file. */
1353 /* It's not one of our sections, so don't allocate space. */
1357 if (s
->_raw_size
== 0)
1359 _bfd_strip_section_from_output (info
, s
);
1363 /* Allocate memory for the section contents. We use bfd_zalloc
1364 here in case unused entries are not reclaimed before the
1365 section's contents are written out. This should not happen,
1366 but this way if it does, we get a R_386_NONE reloc instead
1368 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1369 if (s
->contents
== NULL
)
1373 if (htab
->root
.dynamic_sections_created
)
1375 /* Add some entries to the .dynamic section. We fill in the
1376 values later, in elf_i386_finish_dynamic_sections, but we
1377 must add the entries now so that we get the correct size for
1378 the .dynamic section. The DT_DEBUG entry is filled in by the
1379 dynamic linker and used by the debugger. */
1380 #define add_dynamic_entry(TAG, VAL) \
1381 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1385 if (!add_dynamic_entry (DT_DEBUG
, 0))
1389 if (htab
->splt
->_raw_size
!= 0)
1391 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1392 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1393 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1394 || !add_dynamic_entry (DT_JMPREL
, 0))
1400 if (!add_dynamic_entry (DT_REL
, 0)
1401 || !add_dynamic_entry (DT_RELSZ
, 0)
1402 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1406 if ((info
->flags
& DF_TEXTREL
) != 0)
1408 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1412 #undef add_dynamic_entry
1417 /* Relocate an i386 ELF section. */
1420 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1421 contents
, relocs
, local_syms
, local_sections
)
1423 struct bfd_link_info
*info
;
1425 asection
*input_section
;
1427 Elf_Internal_Rela
*relocs
;
1428 Elf_Internal_Sym
*local_syms
;
1429 asection
**local_sections
;
1431 struct elf_i386_link_hash_table
*htab
;
1433 Elf_Internal_Shdr
*symtab_hdr
;
1434 struct elf_link_hash_entry
**sym_hashes
;
1435 bfd_vma
*local_got_offsets
;
1437 Elf_Internal_Rela
*rel
;
1438 Elf_Internal_Rela
*relend
;
1440 htab
= elf_i386_hash_table (info
);
1441 dynobj
= htab
->root
.dynobj
;
1442 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1443 sym_hashes
= elf_sym_hashes (input_bfd
);
1444 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1448 relend
= relocs
+ input_section
->reloc_count
;
1449 for (; rel
< relend
; rel
++)
1452 reloc_howto_type
*howto
;
1453 unsigned long r_symndx
;
1454 struct elf_link_hash_entry
*h
;
1455 Elf_Internal_Sym
*sym
;
1459 boolean unresolved_reloc
;
1460 bfd_reloc_status_type r
;
1463 r_type
= ELF32_R_TYPE (rel
->r_info
);
1464 if (r_type
== (int) R_386_GNU_VTINHERIT
1465 || r_type
== (int) R_386_GNU_VTENTRY
)
1468 if ((indx
= (unsigned) r_type
) >= R_386_standard
1469 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1470 >= R_386_ext
- R_386_standard
))
1472 bfd_set_error (bfd_error_bad_value
);
1475 howto
= elf_howto_table
+ indx
;
1477 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1479 if (info
->relocateable
)
1481 /* This is a relocateable link. We don't have to change
1482 anything, unless the reloc is against a section symbol,
1483 in which case we have to adjust according to where the
1484 section symbol winds up in the output section. */
1485 if (r_symndx
< symtab_hdr
->sh_info
)
1487 sym
= local_syms
+ r_symndx
;
1488 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1492 sec
= local_sections
[r_symndx
];
1493 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1494 val
+= sec
->output_offset
+ sym
->st_value
;
1495 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1502 /* This is a final link. */
1506 unresolved_reloc
= false;
1507 if (r_symndx
< symtab_hdr
->sh_info
)
1509 sym
= local_syms
+ r_symndx
;
1510 sec
= local_sections
[r_symndx
];
1511 relocation
= (sec
->output_section
->vma
1512 + sec
->output_offset
1517 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1518 while (h
->root
.type
== bfd_link_hash_indirect
1519 || h
->root
.type
== bfd_link_hash_warning
)
1520 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1523 if (h
->root
.type
== bfd_link_hash_defined
1524 || h
->root
.type
== bfd_link_hash_defweak
)
1526 sec
= h
->root
.u
.def
.section
;
1527 if (sec
->output_section
== NULL
)
1528 /* Set a flag that will be cleared later if we find a
1529 relocation value for this symbol. output_section
1530 is typically NULL for symbols satisfied by a shared
1532 unresolved_reloc
= true;
1534 relocation
= (h
->root
.u
.def
.value
1535 + sec
->output_section
->vma
1536 + sec
->output_offset
);
1538 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1540 else if (info
->shared
1541 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1542 && !info
->no_undefined
1543 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1547 if (! ((*info
->callbacks
->undefined_symbol
)
1548 (info
, h
->root
.root
.string
, input_bfd
,
1549 input_section
, rel
->r_offset
,
1550 (!info
->shared
|| info
->no_undefined
1551 || ELF_ST_VISIBILITY (h
->other
)))))
1559 /* Relocation is to the entry for this symbol in the global
1561 if (htab
->sgot
== NULL
)
1568 off
= h
->got
.offset
;
1569 dyn
= htab
->root
.dynamic_sections_created
;
1570 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1574 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1575 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1577 /* This is actually a static link, or it is a
1578 -Bsymbolic link and the symbol is defined
1579 locally, or the symbol was forced to be local
1580 because of a version file. We must initialize
1581 this entry in the global offset table. Since the
1582 offset must always be a multiple of 4, we use the
1583 least significant bit to record whether we have
1584 initialized it already.
1586 When doing a dynamic link, we create a .rel.got
1587 relocation entry to initialize the value. This
1588 is done in the finish_dynamic_symbol routine. */
1593 bfd_put_32 (output_bfd
, relocation
,
1594 htab
->sgot
->contents
+ off
);
1599 unresolved_reloc
= false;
1603 if (local_got_offsets
== NULL
)
1606 off
= local_got_offsets
[r_symndx
];
1608 /* The offset must always be a multiple of 4. We use
1609 the least significant bit to record whether we have
1610 already generated the necessary reloc. */
1615 bfd_put_32 (output_bfd
, relocation
,
1616 htab
->sgot
->contents
+ off
);
1621 Elf_Internal_Rel outrel
;
1623 srelgot
= htab
->srelgot
;
1624 if (srelgot
== NULL
)
1627 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1628 + htab
->sgot
->output_offset
1630 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1631 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1632 (((Elf32_External_Rel
*)
1634 + srelgot
->reloc_count
));
1635 ++srelgot
->reloc_count
;
1638 local_got_offsets
[r_symndx
] |= 1;
1642 if (off
>= (bfd_vma
) -2)
1645 relocation
= htab
->sgot
->output_offset
+ off
;
1649 /* Relocation is relative to the start of the global offset
1652 /* Note that sgot->output_offset is not involved in this
1653 calculation. We always want the start of .got. If we
1654 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1655 permitted by the ABI, we might have to change this
1657 relocation
-= htab
->sgot
->output_section
->vma
;
1661 /* Use global offset table as symbol value. */
1662 relocation
= htab
->sgot
->output_section
->vma
;
1663 unresolved_reloc
= false;
1667 /* Relocation is to the entry for this symbol in the
1668 procedure linkage table. */
1670 /* Resolve a PLT32 reloc against a local symbol directly,
1671 without using the procedure linkage table. */
1675 if (h
->plt
.offset
== (bfd_vma
) -1
1676 || htab
->splt
== NULL
)
1678 /* We didn't make a PLT entry for this symbol. This
1679 happens when statically linking PIC code, or when
1680 using -Bsymbolic. */
1684 relocation
= (htab
->splt
->output_section
->vma
1685 + htab
->splt
->output_offset
1687 unresolved_reloc
= false;
1693 && (input_section
->flags
& SEC_ALLOC
) != 0
1694 && (r_type
!= R_386_PC32
1697 && (! info
->symbolic
1698 || (h
->elf_link_hash_flags
1699 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1701 && (input_section
->flags
& SEC_ALLOC
) != 0
1704 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1705 && (((h
->elf_link_hash_flags
1706 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1707 && (h
->elf_link_hash_flags
1708 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1709 || h
->root
.type
== bfd_link_hash_undefweak
1710 || h
->root
.type
== bfd_link_hash_undefined
)))
1712 Elf_Internal_Rel outrel
;
1713 boolean skip
, relocate
;
1715 /* When generating a shared object, these relocations
1716 are copied into the output file to be resolved at run
1723 name
= (bfd_elf_string_from_elf_section
1725 elf_elfheader (input_bfd
)->e_shstrndx
,
1726 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1730 if (strncmp (name
, ".rel", 4) != 0
1731 || strcmp (bfd_get_section_name (input_bfd
,
1735 (*_bfd_error_handler
)
1736 (_("%s: bad relocation section name `%s\'"),
1737 bfd_archive_filename (input_bfd
), name
);
1741 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1748 if (elf_section_data (input_section
)->stab_info
== NULL
)
1749 outrel
.r_offset
= rel
->r_offset
;
1752 off
= (_bfd_stab_section_offset
1753 (output_bfd
, htab
->root
.stab_info
, input_section
,
1754 &elf_section_data (input_section
)->stab_info
,
1756 if (off
== (bfd_vma
) -1)
1758 outrel
.r_offset
= off
;
1761 outrel
.r_offset
+= (input_section
->output_section
->vma
1762 + input_section
->output_offset
);
1766 memset (&outrel
, 0, sizeof outrel
);
1771 && (r_type
== R_386_PC32
1774 || (h
->elf_link_hash_flags
1775 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1779 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1783 /* This symbol is local, or marked to become local. */
1785 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1788 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1789 (((Elf32_External_Rel
*)
1791 + sreloc
->reloc_count
));
1792 ++sreloc
->reloc_count
;
1794 /* If this reloc is against an external symbol, we do
1795 not want to fiddle with the addend. Otherwise, we
1796 need to include the symbol value so that it becomes
1797 an addend for the dynamic reloc. */
1808 /* FIXME: Why do we allow debugging sections to escape this error?
1809 More importantly, why do we not emit dynamic relocs for
1810 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1811 If we had emitted the dynamic reloc, we could remove the
1813 if (unresolved_reloc
1815 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1816 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1817 (*_bfd_error_handler
)
1818 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1819 bfd_archive_filename (input_bfd
),
1820 bfd_get_section_name (input_bfd
, input_section
),
1821 (long) rel
->r_offset
,
1822 h
->root
.root
.string
);
1824 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1825 contents
, rel
->r_offset
,
1826 relocation
, (bfd_vma
) 0);
1833 case bfd_reloc_overflow
:
1838 name
= h
->root
.root
.string
;
1841 name
= bfd_elf_string_from_elf_section (input_bfd
,
1842 symtab_hdr
->sh_link
,
1847 name
= bfd_section_name (input_bfd
, sec
);
1849 if (! ((*info
->callbacks
->reloc_overflow
)
1850 (info
, name
, howto
->name
, (bfd_vma
) 0,
1851 input_bfd
, input_section
, rel
->r_offset
)))
1857 case bfd_reloc_outofrange
:
1866 /* Finish up dynamic symbol handling. We set the contents of various
1867 dynamic sections here. */
1870 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1872 struct bfd_link_info
*info
;
1873 struct elf_link_hash_entry
*h
;
1874 Elf_Internal_Sym
*sym
;
1876 struct elf_i386_link_hash_table
*htab
;
1879 htab
= elf_i386_hash_table (info
);
1880 dynobj
= htab
->root
.dynobj
;
1882 if (h
->plt
.offset
!= (bfd_vma
) -1)
1886 Elf_Internal_Rel rel
;
1888 /* This symbol has an entry in the procedure linkage table. Set
1891 if (h
->dynindx
== -1
1892 || htab
->splt
== NULL
1893 || htab
->sgotplt
== NULL
1894 || htab
->srelplt
== NULL
)
1897 /* Get the index in the procedure linkage table which
1898 corresponds to this symbol. This is the index of this symbol
1899 in all the symbols for which we are making plt entries. The
1900 first entry in the procedure linkage table is reserved. */
1901 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1903 /* Get the offset into the .got table of the entry that
1904 corresponds to this function. Each .got entry is 4 bytes.
1905 The first three are reserved. */
1906 got_offset
= (plt_index
+ 3) * 4;
1908 /* Fill in the entry in the procedure linkage table. */
1911 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1913 bfd_put_32 (output_bfd
,
1914 (htab
->sgotplt
->output_section
->vma
1915 + htab
->sgotplt
->output_offset
1917 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1921 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1923 bfd_put_32 (output_bfd
, got_offset
,
1924 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1927 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1928 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1929 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1930 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1932 /* Fill in the entry in the global offset table. */
1933 bfd_put_32 (output_bfd
,
1934 (htab
->splt
->output_section
->vma
1935 + htab
->splt
->output_offset
1938 htab
->sgotplt
->contents
+ got_offset
);
1940 /* Fill in the entry in the .rel.plt section. */
1941 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1942 + htab
->sgotplt
->output_offset
1944 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1945 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1946 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1949 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1951 /* Mark the symbol as undefined, rather than as defined in
1952 the .plt section. Leave the value alone. */
1953 sym
->st_shndx
= SHN_UNDEF
;
1957 if (h
->got
.offset
!= (bfd_vma
) -1)
1959 Elf_Internal_Rel rel
;
1961 /* This symbol has an entry in the global offset table. Set it
1964 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
1967 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1968 + htab
->sgot
->output_offset
1969 + (h
->got
.offset
& ~(bfd_vma
) 1));
1971 /* If this is a static link, or it is a -Bsymbolic link and the
1972 symbol is defined locally or was forced to be local because
1973 of a version file, we just want to emit a RELATIVE reloc.
1974 The entry in the global offset table will already have been
1975 initialized in the relocate_section function. */
1979 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1980 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1982 BFD_ASSERT((h
->got
.offset
& 1) != 0);
1983 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1987 BFD_ASSERT((h
->got
.offset
& 1) == 0);
1988 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1989 htab
->sgot
->contents
+ h
->got
.offset
);
1990 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
1993 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1994 ((Elf32_External_Rel
*) htab
->srelgot
->contents
1995 + htab
->srelgot
->reloc_count
));
1996 ++htab
->srelgot
->reloc_count
;
1999 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2001 Elf_Internal_Rel rel
;
2003 /* This symbol needs a copy reloc. Set it up. */
2005 if (h
->dynindx
== -1
2006 || (h
->root
.type
!= bfd_link_hash_defined
2007 && h
->root
.type
!= bfd_link_hash_defweak
)
2008 || htab
->srelbss
== NULL
)
2011 rel
.r_offset
= (h
->root
.u
.def
.value
2012 + h
->root
.u
.def
.section
->output_section
->vma
2013 + h
->root
.u
.def
.section
->output_offset
);
2014 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2015 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2016 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2017 + htab
->srelbss
->reloc_count
));
2018 ++htab
->srelbss
->reloc_count
;
2021 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2022 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2023 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2024 sym
->st_shndx
= SHN_ABS
;
2029 /* Finish up the dynamic sections. */
2032 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2034 struct bfd_link_info
*info
;
2036 struct elf_i386_link_hash_table
*htab
;
2040 htab
= elf_i386_hash_table (info
);
2041 dynobj
= htab
->root
.dynobj
;
2042 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2044 if (htab
->root
.dynamic_sections_created
)
2046 Elf32_External_Dyn
*dyncon
, *dynconend
;
2048 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2051 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2052 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2053 for (; dyncon
< dynconend
; dyncon
++)
2055 Elf_Internal_Dyn dyn
;
2057 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2065 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2066 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2070 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2071 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2075 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2076 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2078 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2079 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2083 /* My reading of the SVR4 ABI indicates that the
2084 procedure linkage table relocs (DT_JMPREL) should be
2085 included in the overall relocs (DT_REL). This is
2086 what Solaris does. However, UnixWare can not handle
2087 that case. Therefore, we override the DT_RELSZ entry
2088 here to make it not include the JMPREL relocs. Since
2089 the linker script arranges for .rel.plt to follow all
2090 other relocation sections, we don't have to worry
2091 about changing the DT_REL entry. */
2092 if (htab
->srelplt
!= NULL
)
2094 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2095 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2097 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2099 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2104 /* Fill in the first entry in the procedure linkage table. */
2105 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2108 memcpy (htab
->splt
->contents
,
2109 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2112 memcpy (htab
->splt
->contents
,
2113 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2114 bfd_put_32 (output_bfd
,
2115 (htab
->sgotplt
->output_section
->vma
2116 + htab
->sgotplt
->output_offset
2118 htab
->splt
->contents
+ 2);
2119 bfd_put_32 (output_bfd
,
2120 (htab
->sgotplt
->output_section
->vma
2121 + htab
->sgotplt
->output_offset
2123 htab
->splt
->contents
+ 8);
2126 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2127 really seem like the right value. */
2128 elf_section_data (htab
->splt
->output_section
)
2129 ->this_hdr
.sh_entsize
= 4;
2135 /* Fill in the first three entries in the global offset table. */
2136 if (htab
->sgotplt
->_raw_size
> 0)
2138 bfd_put_32 (output_bfd
,
2139 (sdyn
== NULL
? (bfd_vma
) 0
2140 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2141 htab
->sgotplt
->contents
);
2142 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2143 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2146 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2151 /* Set the correct type for an x86 ELF section. We do this by the
2152 section name, which is a hack, but ought to work. */
2155 elf_i386_fake_sections (abfd
, hdr
, sec
)
2156 bfd
*abfd ATTRIBUTE_UNUSED
;
2157 Elf32_Internal_Shdr
*hdr
;
2160 register const char *name
;
2162 name
= bfd_get_section_name (abfd
, sec
);
2164 if (strcmp (name
, ".reloc") == 0)
2166 * This is an ugly, but unfortunately necessary hack that is
2167 * needed when producing EFI binaries on x86. It tells
2168 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2169 * containing ELF relocation info. We need this hack in order to
2170 * be able to generate ELF binaries that can be translated into
2171 * EFI applications (which are essentially COFF objects). Those
2172 * files contain a COFF ".reloc" section inside an ELFNN object,
2173 * which would normally cause BFD to segfault because it would
2174 * attempt to interpret this section as containing relocation
2175 * entries for section "oc". With this hack enabled, ".reloc"
2176 * will be treated as a normal data section, which will avoid the
2177 * segfault. However, you won't be able to create an ELFNN binary
2178 * with a section named "oc" that needs relocations, but that's
2179 * the kind of ugly side-effects you get when detecting section
2180 * types based on their names... In practice, this limitation is
2183 hdr
->sh_type
= SHT_PROGBITS
;
2188 static enum elf_reloc_type_class
2189 elf_i386_reloc_type_class (type
)
2194 case R_386_RELATIVE
:
2195 return reloc_class_relative
;
2196 case R_386_JUMP_SLOT
:
2197 return reloc_class_plt
;
2199 return reloc_class_copy
;
2201 return reloc_class_normal
;
2205 /* Support for core dump NOTE sections */
2207 elf_i386_grok_prstatus (abfd
, note
)
2209 Elf_Internal_Note
*note
;
2214 switch (note
->descsz
)
2219 case 144: /* Linux/i386 */
2221 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2224 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2233 /* Make a ".reg/999" section. */
2234 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2235 raw_size
, note
->descpos
+ offset
);
2239 elf_i386_grok_psinfo (abfd
, note
)
2241 Elf_Internal_Note
*note
;
2243 switch (note
->descsz
)
2248 case 128: /* Linux/MIPS elf_prpsinfo */
2249 elf_tdata (abfd
)->core_program
2250 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
2251 elf_tdata (abfd
)->core_command
2252 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
2255 /* Note that for some reason, a spurious space is tacked
2256 onto the end of the args in some (at least one anyway)
2257 implementations, so strip it off if it exists. */
2260 char *command
= elf_tdata (abfd
)->core_command
;
2261 int n
= strlen (command
);
2263 if (0 < n
&& command
[n
- 1] == ' ')
2264 command
[n
- 1] = '\0';
2270 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2271 #define TARGET_LITTLE_NAME "elf32-i386"
2272 #define ELF_ARCH bfd_arch_i386
2273 #define ELF_MACHINE_CODE EM_386
2274 #define ELF_MAXPAGESIZE 0x1000
2276 #define elf_backend_can_gc_sections 1
2277 #define elf_backend_want_got_plt 1
2278 #define elf_backend_plt_readonly 1
2279 #define elf_backend_want_plt_sym 0
2280 #define elf_backend_got_header_size 12
2281 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2283 #define elf_info_to_howto elf_i386_info_to_howto
2284 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2286 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2287 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2288 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2290 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2291 #define elf_backend_check_relocs elf_i386_check_relocs
2292 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2293 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2294 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2295 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2296 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2297 #define elf_backend_relocate_section elf_i386_relocate_section
2298 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2299 #define elf_backend_fake_sections elf_i386_fake_sections
2300 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2301 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2302 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2304 #include "elf32-target.h"