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
67 PARAMS ((const Elf_Internal_Rela
*));
68 static boolean elf_i386_grok_prstatus
69 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
70 static boolean elf_i386_grok_psinfo
71 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
73 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
77 static reloc_howto_type elf_howto_table
[]=
79 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_386_NONE",
81 true, 0x00000000, 0x00000000, false),
82 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_386_32",
84 true, 0xffffffff, 0xffffffff, false),
85 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_386_PC32",
87 true, 0xffffffff, 0xffffffff, true),
88 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_386_GOT32",
90 true, 0xffffffff, 0xffffffff, false),
91 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_386_PLT32",
93 true, 0xffffffff, 0xffffffff, true),
94 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_386_COPY",
96 true, 0xffffffff, 0xffffffff, false),
97 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
99 true, 0xffffffff, 0xffffffff, false),
100 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
101 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
102 true, 0xffffffff, 0xffffffff, false),
103 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
104 bfd_elf_generic_reloc
, "R_386_RELATIVE",
105 true, 0xffffffff, 0xffffffff, false),
106 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
107 bfd_elf_generic_reloc
, "R_386_GOTOFF",
108 true, 0xffffffff, 0xffffffff, false),
109 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_386_GOTPC",
111 true, 0xffffffff, 0xffffffff, true),
113 /* We have a gap in the reloc numbers here.
114 R_386_standard counts the number up to this point, and
115 R_386_ext_offset is the value to subtract from a reloc type of
116 R_386_16 thru R_386_PC8 to form an index into this table. */
117 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
118 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
120 /* The remaining relocs are a GNU extension. */
121 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
122 bfd_elf_generic_reloc
, "R_386_16",
123 true, 0xffff, 0xffff, false),
124 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
125 bfd_elf_generic_reloc
, "R_386_PC16",
126 true, 0xffff, 0xffff, true),
127 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
128 bfd_elf_generic_reloc
, "R_386_8",
129 true, 0xff, 0xff, false),
130 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
131 bfd_elf_generic_reloc
, "R_386_PC8",
132 true, 0xff, 0xff, true),
135 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
136 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
138 /* GNU extension to record C++ vtable hierarchy. */
139 HOWTO (R_386_GNU_VTINHERIT
, /* type */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
143 false, /* pc_relative */
145 complain_overflow_dont
, /* complain_on_overflow */
146 NULL
, /* special_function */
147 "R_386_GNU_VTINHERIT", /* name */
148 false, /* partial_inplace */
153 /* GNU extension to record C++ vtable member usage. */
154 HOWTO (R_386_GNU_VTENTRY
, /* type */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
158 false, /* pc_relative */
160 complain_overflow_dont
, /* complain_on_overflow */
161 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
162 "R_386_GNU_VTENTRY", /* name */
163 false, /* partial_inplace */
168 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
172 #ifdef DEBUG_GEN_RELOC
173 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
178 static reloc_howto_type
*
179 elf_i386_reloc_type_lookup (abfd
, code
)
180 bfd
*abfd ATTRIBUTE_UNUSED
;
181 bfd_reloc_code_real_type code
;
186 TRACE ("BFD_RELOC_NONE");
187 return &elf_howto_table
[(unsigned int) R_386_NONE
];
190 TRACE ("BFD_RELOC_32");
191 return &elf_howto_table
[(unsigned int) R_386_32
];
194 TRACE ("BFD_RELOC_CTOR");
195 return &elf_howto_table
[(unsigned int) R_386_32
];
197 case BFD_RELOC_32_PCREL
:
198 TRACE ("BFD_RELOC_PC32");
199 return &elf_howto_table
[(unsigned int) R_386_PC32
];
201 case BFD_RELOC_386_GOT32
:
202 TRACE ("BFD_RELOC_386_GOT32");
203 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
205 case BFD_RELOC_386_PLT32
:
206 TRACE ("BFD_RELOC_386_PLT32");
207 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
209 case BFD_RELOC_386_COPY
:
210 TRACE ("BFD_RELOC_386_COPY");
211 return &elf_howto_table
[(unsigned int) R_386_COPY
];
213 case BFD_RELOC_386_GLOB_DAT
:
214 TRACE ("BFD_RELOC_386_GLOB_DAT");
215 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
217 case BFD_RELOC_386_JUMP_SLOT
:
218 TRACE ("BFD_RELOC_386_JUMP_SLOT");
219 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
221 case BFD_RELOC_386_RELATIVE
:
222 TRACE ("BFD_RELOC_386_RELATIVE");
223 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
225 case BFD_RELOC_386_GOTOFF
:
226 TRACE ("BFD_RELOC_386_GOTOFF");
227 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
229 case BFD_RELOC_386_GOTPC
:
230 TRACE ("BFD_RELOC_386_GOTPC");
231 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
233 /* The remaining relocs are a GNU extension. */
235 TRACE ("BFD_RELOC_16");
236 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
238 case BFD_RELOC_16_PCREL
:
239 TRACE ("BFD_RELOC_16_PCREL");
240 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
243 TRACE ("BFD_RELOC_8");
244 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
246 case BFD_RELOC_8_PCREL
:
247 TRACE ("BFD_RELOC_8_PCREL");
248 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
250 case BFD_RELOC_VTABLE_INHERIT
:
251 TRACE ("BFD_RELOC_VTABLE_INHERIT");
252 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
255 case BFD_RELOC_VTABLE_ENTRY
:
256 TRACE ("BFD_RELOC_VTABLE_ENTRY");
257 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
269 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
270 bfd
*abfd ATTRIBUTE_UNUSED
;
271 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
272 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
278 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
279 bfd
*abfd ATTRIBUTE_UNUSED
;
281 Elf32_Internal_Rel
*dst
;
283 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
286 if ((indx
= r_type
) >= R_386_standard
287 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
288 >= R_386_ext
- R_386_standard
)
289 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
290 >= R_386_vt
- R_386_ext
))
292 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
293 bfd_archive_filename (abfd
), (int) r_type
);
294 indx
= (unsigned int) R_386_NONE
;
296 cache_ptr
->howto
= &elf_howto_table
[indx
];
299 /* Return whether a symbol name implies a local label. The UnixWare
300 2.1 cc generates temporary symbols that start with .X, so we
301 recognize them here. FIXME: do other SVR4 compilers also use .X?.
302 If so, we should move the .X recognition into
303 _bfd_elf_is_local_label_name. */
306 elf_i386_is_local_label_name (abfd
, name
)
310 if (name
[0] == '.' && name
[1] == 'X')
313 return _bfd_elf_is_local_label_name (abfd
, name
);
316 /* Functions for the i386 ELF linker. */
318 /* The name of the dynamic interpreter. This is put in the .interp
321 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
323 /* The size in bytes of an entry in the procedure linkage table. */
325 #define PLT_ENTRY_SIZE 16
327 /* The first entry in an absolute procedure linkage table looks like
328 this. See the SVR4 ABI i386 supplement to see how this works. */
330 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
332 0xff, 0x35, /* pushl contents of address */
333 0, 0, 0, 0, /* replaced with address of .got + 4. */
334 0xff, 0x25, /* jmp indirect */
335 0, 0, 0, 0, /* replaced with address of .got + 8. */
336 0, 0, 0, 0 /* pad out to 16 bytes. */
339 /* Subsequent entries in an absolute procedure linkage table look like
342 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
344 0xff, 0x25, /* jmp indirect */
345 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
346 0x68, /* pushl immediate */
347 0, 0, 0, 0, /* replaced with offset into relocation table. */
348 0xe9, /* jmp relative */
349 0, 0, 0, 0 /* replaced with offset to start of .plt. */
352 /* The first entry in a PIC procedure linkage table look like this. */
354 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
356 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
357 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
358 0, 0, 0, 0 /* pad out to 16 bytes. */
361 /* Subsequent entries in a PIC procedure linkage table look like this. */
363 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
365 0xff, 0xa3, /* jmp *offset(%ebx) */
366 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
367 0x68, /* pushl immediate */
368 0, 0, 0, 0, /* replaced with offset into relocation table. */
369 0xe9, /* jmp relative */
370 0, 0, 0, 0 /* replaced with offset to start of .plt. */
373 /* The i386 linker needs to keep track of the number of relocs that it
374 decides to copy as dynamic relocs in check_relocs for each symbol.
375 This is so that it can later discard them if they are found to be
376 unnecessary. We store the information in a field extending the
377 regular ELF linker hash table. */
379 struct elf_i386_dyn_relocs
382 struct elf_i386_dyn_relocs
*next
;
383 /* A section in dynobj. */
385 /* Number of relocs copied in this section. */
389 /* i386 ELF linker hash entry. */
391 struct elf_i386_link_hash_entry
393 struct elf_link_hash_entry root
;
395 /* Number of PC relative relocs copied for this symbol. */
396 struct elf_i386_dyn_relocs
*dyn_relocs
;
399 /* i386 ELF linker hash table. */
401 struct elf_i386_link_hash_table
403 struct elf_link_hash_table root
;
405 /* Short-cuts to get to dynamic linker sections. */
415 /* Get the i386 ELF linker hash table from a link_info structure. */
417 #define elf_i386_hash_table(p) \
418 ((struct elf_i386_link_hash_table *) ((p)->hash))
420 /* Create an entry in an i386 ELF linker hash table. */
422 static struct bfd_hash_entry
*
423 elf_i386_link_hash_newfunc (entry
, table
, string
)
424 struct bfd_hash_entry
*entry
;
425 struct bfd_hash_table
*table
;
428 struct elf_i386_link_hash_entry
*ret
=
429 (struct elf_i386_link_hash_entry
*) entry
;
431 /* Allocate the structure if it has not already been allocated by a
433 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
434 ret
= ((struct elf_i386_link_hash_entry
*)
435 bfd_hash_allocate (table
,
436 sizeof (struct elf_i386_link_hash_entry
)));
437 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
438 return (struct bfd_hash_entry
*) ret
;
440 /* Call the allocation method of the superclass. */
441 ret
= ((struct elf_i386_link_hash_entry
*)
442 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
444 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
446 ret
->dyn_relocs
= NULL
;
449 return (struct bfd_hash_entry
*) ret
;
452 /* Create an i386 ELF linker hash table. */
454 static struct bfd_link_hash_table
*
455 elf_i386_link_hash_table_create (abfd
)
458 struct elf_i386_link_hash_table
*ret
;
459 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
461 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
462 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
465 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
466 elf_i386_link_hash_newfunc
))
468 bfd_release (abfd
, ret
);
480 return &ret
->root
.root
;
483 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
484 shortcuts to them in our hash table. */
487 create_got_section (dynobj
, info
)
489 struct bfd_link_info
*info
;
491 struct elf_i386_link_hash_table
*htab
;
493 if (! _bfd_elf_create_got_section (dynobj
, info
))
496 htab
= elf_i386_hash_table (info
);
497 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
498 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
499 if (!htab
->sgot
|| !htab
->sgotplt
)
502 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
503 if (htab
->srelgot
== NULL
504 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
505 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
506 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
508 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
513 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
514 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
518 elf_i386_create_dynamic_sections (dynobj
, info
)
520 struct bfd_link_info
*info
;
522 struct elf_i386_link_hash_table
*htab
;
524 htab
= elf_i386_hash_table (info
);
525 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
528 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
531 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
532 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
533 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
535 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
537 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
538 || (!info
->shared
&& !htab
->srelbss
))
544 /* Look through the relocs for a section during the first phase, and
545 allocate space in the global offset table or procedure linkage
549 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
551 struct bfd_link_info
*info
;
553 const Elf_Internal_Rela
*relocs
;
555 struct elf_i386_link_hash_table
*htab
;
557 Elf_Internal_Shdr
*symtab_hdr
;
558 struct elf_link_hash_entry
**sym_hashes
;
559 bfd_signed_vma
*local_got_refcounts
;
560 const Elf_Internal_Rela
*rel
;
561 const Elf_Internal_Rela
*rel_end
;
564 if (info
->relocateable
)
567 htab
= elf_i386_hash_table (info
);
568 dynobj
= htab
->root
.dynobj
;
569 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
570 sym_hashes
= elf_sym_hashes (abfd
);
571 local_got_refcounts
= elf_local_got_refcounts (abfd
);
575 rel_end
= relocs
+ sec
->reloc_count
;
576 for (rel
= relocs
; rel
< rel_end
; rel
++)
578 unsigned long r_symndx
;
579 struct elf_link_hash_entry
*h
;
581 r_symndx
= ELF32_R_SYM (rel
->r_info
);
583 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
585 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
586 bfd_archive_filename (abfd
),
591 if (r_symndx
< symtab_hdr
->sh_info
)
594 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
596 /* Some relocs require a global offset table. */
597 if (htab
->sgot
== NULL
)
599 switch (ELF32_R_TYPE (rel
->r_info
))
605 htab
->root
.dynobj
= dynobj
= abfd
;
606 if (!create_got_section (dynobj
, info
))
615 switch (ELF32_R_TYPE (rel
->r_info
))
618 /* This symbol requires a global offset table entry. */
621 if (h
->got
.refcount
== -1)
624 h
->got
.refcount
+= 1;
628 /* This is a global offset table entry for a local symbol. */
629 if (local_got_refcounts
== NULL
)
633 size
= symtab_hdr
->sh_info
;
634 size
*= sizeof (bfd_signed_vma
);
635 local_got_refcounts
= ((bfd_signed_vma
*)
636 bfd_alloc (abfd
, size
));
637 if (local_got_refcounts
== NULL
)
639 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
640 memset (local_got_refcounts
, -1, (size_t) size
);
642 if (local_got_refcounts
[r_symndx
] == -1)
643 local_got_refcounts
[r_symndx
] = 1;
645 local_got_refcounts
[r_symndx
] += 1;
650 /* This symbol requires a procedure linkage table entry. We
651 actually build the entry in adjust_dynamic_symbol,
652 because this might be a case of linking PIC code which is
653 never referenced by a dynamic object, in which case we
654 don't need to generate a procedure linkage table entry
657 /* If this is a local symbol, we resolve it directly without
658 creating a procedure linkage table entry. */
662 if (h
->plt
.refcount
== -1)
664 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
668 h
->plt
.refcount
+= 1;
673 if (h
!= NULL
&& !info
->shared
)
675 /* If this reloc is in a read-only section, we might
676 need a copy reloc. */
677 if ((sec
->flags
& SEC_READONLY
) != 0)
678 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
680 /* We may need a .plt entry if the function this reloc
681 refers to is in a shared lib. */
682 if (h
->plt
.refcount
== -1)
685 h
->plt
.refcount
+= 1;
688 /* If we are creating a shared library, and this is a reloc
689 against a global symbol, or a non PC relative reloc
690 against a local symbol, then we need to copy the reloc
691 into the shared library. However, if we are linking with
692 -Bsymbolic, we do not need to copy a reloc against a
693 global symbol which is defined in an object we are
694 including in the link (i.e., DEF_REGULAR is set). At
695 this point we have not seen all the input files, so it is
696 possible that DEF_REGULAR is not set now but will be set
697 later (it is never cleared). In case of a weak definition,
698 DEF_REGULAR may be cleared later by a strong definition in
699 a shared library. We account for that possibility below by
700 storing information in the relocs_copied field of the hash
701 table entry. A similar situation occurs when creating
702 shared libraries and symbol visibility changes render the
705 If on the other hand, we are creating an executable, we
706 may need to keep relocations for symbols satisfied by a
707 dynamic library if we manage to avoid copy relocs for the
710 && (sec
->flags
& SEC_ALLOC
) != 0
711 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
714 || h
->root
.type
== bfd_link_hash_defweak
715 || (h
->elf_link_hash_flags
716 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
718 && (sec
->flags
& SEC_ALLOC
) != 0
720 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
721 && (h
->root
.type
== bfd_link_hash_defweak
722 || (h
->elf_link_hash_flags
723 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
725 /* We must copy these reloc types into the output file.
726 Create a reloc section in dynobj and make room for
729 htab
->root
.dynobj
= dynobj
= abfd
;
735 name
= (bfd_elf_string_from_elf_section
737 elf_elfheader (abfd
)->e_shstrndx
,
738 elf_section_data (sec
)->rel_hdr
.sh_name
));
742 if (strncmp (name
, ".rel", 4) != 0
743 || strcmp (bfd_get_section_name (abfd
, sec
),
746 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
747 bfd_archive_filename (abfd
),
751 sreloc
= bfd_get_section_by_name (dynobj
, name
);
756 sreloc
= bfd_make_section (dynobj
, name
);
757 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
758 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
759 if ((sec
->flags
& SEC_ALLOC
) != 0)
760 flags
|= SEC_ALLOC
| SEC_LOAD
;
762 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
763 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
766 if (sec
->flags
& SEC_READONLY
)
767 info
->flags
|= DF_TEXTREL
;
770 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
772 /* If this is a global symbol, we count the number of PC
773 relative relocations we have entered for this symbol,
774 so that we can discard them later as necessary. Note
775 that this function is only called if we are using an
776 elf_i386 linker hash table, which means that h is
777 really a pointer to an elf_i386_link_hash_entry. */
780 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
))
782 struct elf_i386_link_hash_entry
*eh
;
783 struct elf_i386_dyn_relocs
*p
;
785 eh
= (struct elf_i386_link_hash_entry
*) h
;
787 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
788 if (p
->section
== sreloc
)
793 p
= ((struct elf_i386_dyn_relocs
*)
794 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
797 p
->next
= eh
->dyn_relocs
;
809 /* This relocation describes the C++ object vtable hierarchy.
810 Reconstruct it for later use during GC. */
811 case R_386_GNU_VTINHERIT
:
812 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
816 /* This relocation describes which C++ vtable entries are actually
817 used. Record for later use during GC. */
818 case R_386_GNU_VTENTRY
:
819 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
831 /* Return the section that should be marked against GC for a given
835 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
837 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
838 Elf_Internal_Rela
*rel
;
839 struct elf_link_hash_entry
*h
;
840 Elf_Internal_Sym
*sym
;
844 switch (ELF32_R_TYPE (rel
->r_info
))
846 case R_386_GNU_VTINHERIT
:
847 case R_386_GNU_VTENTRY
:
851 switch (h
->root
.type
)
853 case bfd_link_hash_defined
:
854 case bfd_link_hash_defweak
:
855 return h
->root
.u
.def
.section
;
857 case bfd_link_hash_common
:
858 return h
->root
.u
.c
.p
->section
;
867 if (!(elf_bad_symtab (abfd
)
868 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
869 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
870 && sym
->st_shndx
!= SHN_COMMON
))
872 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
879 /* Update the got entry reference counts for the section being removed. */
882 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
884 struct bfd_link_info
*info
;
886 const Elf_Internal_Rela
*relocs
;
888 Elf_Internal_Shdr
*symtab_hdr
;
889 struct elf_link_hash_entry
**sym_hashes
;
890 bfd_signed_vma
*local_got_refcounts
;
891 const Elf_Internal_Rela
*rel
, *relend
;
892 unsigned long r_symndx
;
893 struct elf_link_hash_entry
*h
;
896 dynobj
= elf_hash_table (info
)->dynobj
;
900 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
901 sym_hashes
= elf_sym_hashes (abfd
);
902 local_got_refcounts
= elf_local_got_refcounts (abfd
);
904 relend
= relocs
+ sec
->reloc_count
;
905 for (rel
= relocs
; rel
< relend
; rel
++)
906 switch (ELF32_R_TYPE (rel
->r_info
))
911 r_symndx
= ELF32_R_SYM (rel
->r_info
);
912 if (r_symndx
>= symtab_hdr
->sh_info
)
914 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
915 if (h
->got
.refcount
> 0)
916 h
->got
.refcount
-= 1;
918 else if (local_got_refcounts
!= NULL
)
920 if (local_got_refcounts
[r_symndx
] > 0)
921 local_got_refcounts
[r_symndx
] -= 1;
932 r_symndx
= ELF32_R_SYM (rel
->r_info
);
933 if (r_symndx
>= symtab_hdr
->sh_info
)
935 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
936 if (h
->plt
.refcount
> 0)
937 h
->plt
.refcount
-= 1;
948 /* Adjust a symbol defined by a dynamic object and referenced by a
949 regular object. The current definition is in some section of the
950 dynamic object, but we're not including those sections. We have to
951 change the definition to something the rest of the link can
955 elf_i386_adjust_dynamic_symbol (info
, h
)
956 struct bfd_link_info
*info
;
957 struct elf_link_hash_entry
*h
;
959 struct elf_i386_link_hash_table
*htab
;
962 unsigned int power_of_two
;
964 htab
= elf_i386_hash_table (info
);
965 dynobj
= htab
->root
.dynobj
;
967 /* If this is a function, put it in the procedure linkage table. We
968 will fill in the contents of the procedure linkage table later,
969 when we know the address of the .got section. */
970 if (h
->type
== STT_FUNC
971 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
973 if (h
->plt
.refcount
<= 0
975 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
976 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
978 /* This case can occur if we saw a PLT32 reloc in an input
979 file, but the symbol was never referred to by a dynamic
980 object, or if all references were garbage collected. In
981 such a case, we don't actually need to build a procedure
982 linkage table, and we can just do a PC32 reloc instead. */
983 h
->plt
.refcount
= (bfd_vma
) -1;
984 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
990 /* It's possible that we incorrectly decided a .plt reloc was
991 needed for an R_386_PC32 reloc to a non-function sym in
992 check_relocs. We can't decide accurately between function and
993 non-function syms in check-relocs; Objects loaded later in
994 the link may change h->type. So fix it now. */
995 h
->plt
.refcount
= (bfd_vma
) -1;
997 /* If this is a weak symbol, and there is a real definition, the
998 processor independent code will have arranged for us to see the
999 real definition first, and we can just use the same value. */
1000 if (h
->weakdef
!= NULL
)
1002 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1003 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1004 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1005 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1009 /* This is a reference to a symbol defined by a dynamic object which
1010 is not a function. */
1012 /* If we are creating a shared library, we must presume that the
1013 only references to the symbol are via the global offset table.
1014 For such cases we need not do anything here; the relocations will
1015 be handled correctly by relocate_section. */
1019 /* If there are no references to this symbol that do not use the
1020 GOT, we don't need to generate a copy reloc. */
1021 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1024 /* We must allocate the symbol in our .dynbss section, which will
1025 become part of the .bss section of the executable. There will be
1026 an entry for this symbol in the .dynsym section. The dynamic
1027 object will contain position independent code, so all references
1028 from the dynamic object to this symbol will go through the global
1029 offset table. The dynamic linker will use the .dynsym entry to
1030 determine the address it must put in the global offset table, so
1031 both the dynamic object and the regular object will refer to the
1032 same memory location for the variable. */
1038 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1039 copy the initial value out of the dynamic object and into the
1040 runtime process image. We need to remember the offset into the
1041 .rel.bss section we are going to use. */
1042 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1046 srel
= htab
->srelbss
;
1049 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1050 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1053 /* We need to figure out the alignment required for this symbol. I
1054 have no idea how ELF linkers handle this. */
1055 power_of_two
= bfd_log2 (h
->size
);
1056 if (power_of_two
> 3)
1059 /* Apply the required alignment. */
1060 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1061 (bfd_size_type
) (1 << power_of_two
));
1062 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1064 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1068 /* Define the symbol as being at this point in the section. */
1069 h
->root
.u
.def
.section
= s
;
1070 h
->root
.u
.def
.value
= s
->_raw_size
;
1072 /* Increment the section size to make room for the symbol. */
1073 s
->_raw_size
+= h
->size
;
1078 /* This is the condition under which elf_i386_finish_dynamic_symbol
1079 will be called from elflink.h. If elflink.h doesn't call our
1080 finish_dynamic_symbol routine, we'll need to do something about
1081 initializing any .plt and .got entries in elf_i386_relocate_section. */
1082 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1084 && ((INFO)->shared \
1085 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1086 && ((H)->dynindx != -1 \
1087 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1089 /* Allocate space in .plt, .got and associated reloc sections for
1090 global syms. Also discards space allocated for relocs in the
1091 check_relocs function that we subsequently have found to be
1095 allocate_plt_and_got_and_discard_relocs (h
, inf
)
1096 struct elf_link_hash_entry
*h
;
1099 struct bfd_link_info
*info
;
1100 struct elf_i386_link_hash_table
*htab
;
1102 struct elf_i386_link_hash_entry
*eh
;
1104 if (h
->root
.type
== bfd_link_hash_indirect
1105 || h
->root
.type
== bfd_link_hash_warning
)
1108 info
= (struct bfd_link_info
*) inf
;
1109 htab
= elf_i386_hash_table (info
);
1111 if (htab
->root
.dynamic_sections_created
1112 && h
->plt
.refcount
> 0)
1114 /* Make sure this symbol is output as a dynamic symbol.
1115 Undefined weak syms won't yet be marked as dynamic. */
1116 if (h
->dynindx
== -1
1117 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1119 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1127 /* If this is the first .plt entry, make room for the special
1129 if (s
->_raw_size
== 0)
1130 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1132 h
->plt
.offset
= s
->_raw_size
;
1134 /* If this symbol is not defined in a regular file, and we are
1135 not generating a shared library, then set the symbol to this
1136 location in the .plt. This is required to make function
1137 pointers compare as equal between the normal executable and
1138 the shared library. */
1140 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1142 h
->root
.u
.def
.section
= s
;
1143 h
->root
.u
.def
.value
= h
->plt
.offset
;
1146 /* Make room for this entry. */
1147 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1149 /* We also need to make an entry in the .got.plt section, which
1150 will be placed in the .got section by the linker script. */
1156 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1158 /* We also need to make an entry in the .rel.plt section. */
1162 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1167 h
->plt
.offset
= (bfd_vma
) -1;
1168 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1171 if (h
->got
.refcount
> 0)
1175 /* Make sure this symbol is output as a dynamic symbol.
1176 Undefined weak syms won't yet be marked as dynamic. */
1177 if (h
->dynindx
== -1
1178 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1180 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1185 h
->got
.offset
= s
->_raw_size
;
1187 dyn
= htab
->root
.dynamic_sections_created
;
1188 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1189 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1192 h
->got
.offset
= (bfd_vma
) -1;
1194 /* In the shared -Bsymbolic case, discard space allocated for
1195 dynamic relocs against symbols which turn out to be defined
1196 in regular objects. For the normal shared case, discard space
1197 for relocs that have become local due to symbol visibility
1198 changes. For the non-shared case, discard space for symbols
1199 which turn out to need copy relocs or are not dynamic. */
1201 eh
= (struct elf_i386_link_hash_entry
*) h
;
1202 if (eh
->dyn_relocs
== NULL
)
1206 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1207 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1208 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1209 || (htab
->root
.dynamic_sections_created
1210 && (h
->root
.type
== bfd_link_hash_undefweak
1211 || h
->root
.type
== bfd_link_hash_undefined
))))
1213 /* Make sure this symbol is output as a dynamic symbol.
1214 Undefined weak syms won't yet be marked as dynamic. */
1215 if (h
->dynindx
== -1
1216 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1218 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1222 /* If that succeeded, we know we'll be keeping all the relocs. */
1223 if (h
->dynindx
!= -1)
1228 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1229 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1230 || info
->symbolic
)))
1232 struct elf_i386_dyn_relocs
*c
;
1234 for (c
= eh
->dyn_relocs
; c
!= NULL
; c
= c
->next
)
1235 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1241 /* Set the sizes of the dynamic sections. */
1244 elf_i386_size_dynamic_sections (output_bfd
, info
)
1245 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1246 struct bfd_link_info
*info
;
1248 struct elf_i386_link_hash_table
*htab
;
1254 htab
= elf_i386_hash_table (info
);
1255 dynobj
= htab
->root
.dynobj
;
1259 if (htab
->root
.dynamic_sections_created
)
1261 /* Set the contents of the .interp section to the interpreter. */
1264 s
= bfd_get_section_by_name (dynobj
, ".interp");
1267 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1268 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1272 /* Set up .got offsets for local syms. */
1273 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1275 bfd_signed_vma
*local_got
;
1276 bfd_signed_vma
*end_local_got
;
1277 bfd_size_type locsymcount
;
1278 Elf_Internal_Shdr
*symtab_hdr
;
1281 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1284 local_got
= elf_local_got_refcounts (i
);
1288 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1289 locsymcount
= symtab_hdr
->sh_info
;
1290 end_local_got
= local_got
+ locsymcount
;
1292 srel
= htab
->srelgot
;
1293 for (; local_got
< end_local_got
; ++local_got
)
1297 *local_got
= s
->_raw_size
;
1300 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1303 *local_got
= (bfd_vma
) -1;
1307 /* Allocate global sym .plt and .got entries. Also discard all
1309 elf_link_hash_traverse (&htab
->root
,
1310 allocate_plt_and_got_and_discard_relocs
,
1313 /* We now have determined the sizes of the various dynamic sections.
1314 Allocate memory for them. */
1316 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1318 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1323 || s
== htab
->sgotplt
)
1325 /* Strip this section if we don't need it; see the
1328 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1330 if (s
->_raw_size
== 0)
1332 /* If we don't need this section, strip it from the
1333 output file. This is mostly to handle .rel.bss and
1334 .rel.plt. We must create both sections in
1335 create_dynamic_sections, because they must be created
1336 before the linker maps input sections to output
1337 sections. The linker does that before
1338 adjust_dynamic_symbol is called, and it is that
1339 function which decides whether anything needs to go
1340 into these sections. */
1344 if (s
!= htab
->srelplt
)
1347 /* We use the reloc_count field as a counter if we need
1348 to copy relocs into the output file. */
1354 /* It's not one of our sections, so don't allocate space. */
1358 if (s
->_raw_size
== 0)
1360 _bfd_strip_section_from_output (info
, s
);
1364 /* Allocate memory for the section contents. We use bfd_zalloc
1365 here in case unused entries are not reclaimed before the
1366 section's contents are written out. This should not happen,
1367 but this way if it does, we get a R_386_NONE reloc instead
1369 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1370 if (s
->contents
== NULL
)
1374 if (htab
->root
.dynamic_sections_created
)
1376 /* Add some entries to the .dynamic section. We fill in the
1377 values later, in elf_i386_finish_dynamic_sections, but we
1378 must add the entries now so that we get the correct size for
1379 the .dynamic section. The DT_DEBUG entry is filled in by the
1380 dynamic linker and used by the debugger. */
1381 #define add_dynamic_entry(TAG, VAL) \
1382 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1386 if (!add_dynamic_entry (DT_DEBUG
, 0))
1390 if (htab
->splt
->_raw_size
!= 0)
1392 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1393 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1394 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1395 || !add_dynamic_entry (DT_JMPREL
, 0))
1401 if (!add_dynamic_entry (DT_REL
, 0)
1402 || !add_dynamic_entry (DT_RELSZ
, 0)
1403 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1407 if ((info
->flags
& DF_TEXTREL
) != 0)
1409 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1413 #undef add_dynamic_entry
1418 /* Relocate an i386 ELF section. */
1421 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1422 contents
, relocs
, local_syms
, local_sections
)
1424 struct bfd_link_info
*info
;
1426 asection
*input_section
;
1428 Elf_Internal_Rela
*relocs
;
1429 Elf_Internal_Sym
*local_syms
;
1430 asection
**local_sections
;
1432 struct elf_i386_link_hash_table
*htab
;
1434 Elf_Internal_Shdr
*symtab_hdr
;
1435 struct elf_link_hash_entry
**sym_hashes
;
1436 bfd_vma
*local_got_offsets
;
1438 Elf_Internal_Rela
*rel
;
1439 Elf_Internal_Rela
*relend
;
1441 htab
= elf_i386_hash_table (info
);
1442 dynobj
= htab
->root
.dynobj
;
1443 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1444 sym_hashes
= elf_sym_hashes (input_bfd
);
1445 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1449 relend
= relocs
+ input_section
->reloc_count
;
1450 for (; rel
< relend
; rel
++)
1453 reloc_howto_type
*howto
;
1454 unsigned long r_symndx
;
1455 struct elf_link_hash_entry
*h
;
1456 Elf_Internal_Sym
*sym
;
1460 boolean unresolved_reloc
;
1461 bfd_reloc_status_type r
;
1464 r_type
= ELF32_R_TYPE (rel
->r_info
);
1465 if (r_type
== (int) R_386_GNU_VTINHERIT
1466 || r_type
== (int) R_386_GNU_VTENTRY
)
1469 if ((indx
= (unsigned) r_type
) >= R_386_standard
1470 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1471 >= R_386_ext
- R_386_standard
))
1473 bfd_set_error (bfd_error_bad_value
);
1476 howto
= elf_howto_table
+ indx
;
1478 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1480 if (info
->relocateable
)
1482 /* This is a relocateable link. We don't have to change
1483 anything, unless the reloc is against a section symbol,
1484 in which case we have to adjust according to where the
1485 section symbol winds up in the output section. */
1486 if (r_symndx
< symtab_hdr
->sh_info
)
1488 sym
= local_syms
+ r_symndx
;
1489 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1493 sec
= local_sections
[r_symndx
];
1494 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1495 val
+= sec
->output_offset
+ sym
->st_value
;
1496 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1503 /* This is a final link. */
1507 unresolved_reloc
= false;
1508 if (r_symndx
< symtab_hdr
->sh_info
)
1510 sym
= local_syms
+ r_symndx
;
1511 sec
= local_sections
[r_symndx
];
1512 relocation
= (sec
->output_section
->vma
1513 + sec
->output_offset
1518 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1519 while (h
->root
.type
== bfd_link_hash_indirect
1520 || h
->root
.type
== bfd_link_hash_warning
)
1521 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1524 if (h
->root
.type
== bfd_link_hash_defined
1525 || h
->root
.type
== bfd_link_hash_defweak
)
1527 sec
= h
->root
.u
.def
.section
;
1528 if (sec
->output_section
== NULL
)
1529 /* Set a flag that will be cleared later if we find a
1530 relocation value for this symbol. output_section
1531 is typically NULL for symbols satisfied by a shared
1533 unresolved_reloc
= true;
1535 relocation
= (h
->root
.u
.def
.value
1536 + sec
->output_section
->vma
1537 + sec
->output_offset
);
1539 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1541 else if (info
->shared
1542 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1543 && !info
->no_undefined
1544 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1548 if (! ((*info
->callbacks
->undefined_symbol
)
1549 (info
, h
->root
.root
.string
, input_bfd
,
1550 input_section
, rel
->r_offset
,
1551 (!info
->shared
|| info
->no_undefined
1552 || ELF_ST_VISIBILITY (h
->other
)))))
1560 /* Relocation is to the entry for this symbol in the global
1562 if (htab
->sgot
== NULL
)
1569 off
= h
->got
.offset
;
1570 dyn
= htab
->root
.dynamic_sections_created
;
1571 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1575 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1576 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1578 /* This is actually a static link, or it is a
1579 -Bsymbolic link and the symbol is defined
1580 locally, or the symbol was forced to be local
1581 because of a version file. We must initialize
1582 this entry in the global offset table. Since the
1583 offset must always be a multiple of 4, we use the
1584 least significant bit to record whether we have
1585 initialized it already.
1587 When doing a dynamic link, we create a .rel.got
1588 relocation entry to initialize the value. This
1589 is done in the finish_dynamic_symbol routine. */
1594 bfd_put_32 (output_bfd
, relocation
,
1595 htab
->sgot
->contents
+ off
);
1600 unresolved_reloc
= false;
1604 if (local_got_offsets
== NULL
)
1607 off
= local_got_offsets
[r_symndx
];
1609 /* The offset must always be a multiple of 4. We use
1610 the least significant bit to record whether we have
1611 already generated the necessary reloc. */
1616 bfd_put_32 (output_bfd
, relocation
,
1617 htab
->sgot
->contents
+ off
);
1622 Elf_Internal_Rel outrel
;
1624 srelgot
= htab
->srelgot
;
1625 if (srelgot
== NULL
)
1628 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1629 + htab
->sgot
->output_offset
1631 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1632 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1633 (((Elf32_External_Rel
*)
1635 + srelgot
->reloc_count
));
1636 ++srelgot
->reloc_count
;
1639 local_got_offsets
[r_symndx
] |= 1;
1643 if (off
>= (bfd_vma
) -2)
1646 relocation
= htab
->sgot
->output_offset
+ off
;
1650 /* Relocation is relative to the start of the global offset
1653 /* Note that sgot->output_offset is not involved in this
1654 calculation. We always want the start of .got. If we
1655 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1656 permitted by the ABI, we might have to change this
1658 relocation
-= htab
->sgot
->output_section
->vma
;
1662 /* Use global offset table as symbol value. */
1663 relocation
= htab
->sgot
->output_section
->vma
;
1664 unresolved_reloc
= false;
1668 /* Relocation is to the entry for this symbol in the
1669 procedure linkage table. */
1671 /* Resolve a PLT32 reloc against a local symbol directly,
1672 without using the procedure linkage table. */
1676 if (h
->plt
.offset
== (bfd_vma
) -1
1677 || htab
->splt
== NULL
)
1679 /* We didn't make a PLT entry for this symbol. This
1680 happens when statically linking PIC code, or when
1681 using -Bsymbolic. */
1685 relocation
= (htab
->splt
->output_section
->vma
1686 + htab
->splt
->output_offset
1688 unresolved_reloc
= false;
1694 && (input_section
->flags
& SEC_ALLOC
) != 0
1695 && (r_type
!= R_386_PC32
1698 && (! info
->symbolic
1699 || (h
->elf_link_hash_flags
1700 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1702 && (input_section
->flags
& SEC_ALLOC
) != 0
1705 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1706 && (((h
->elf_link_hash_flags
1707 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1708 && (h
->elf_link_hash_flags
1709 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1710 || h
->root
.type
== bfd_link_hash_undefweak
1711 || h
->root
.type
== bfd_link_hash_undefined
)))
1713 Elf_Internal_Rel outrel
;
1714 boolean skip
, relocate
;
1716 /* When generating a shared object, these relocations
1717 are copied into the output file to be resolved at run
1724 name
= (bfd_elf_string_from_elf_section
1726 elf_elfheader (input_bfd
)->e_shstrndx
,
1727 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1731 if (strncmp (name
, ".rel", 4) != 0
1732 || strcmp (bfd_get_section_name (input_bfd
,
1736 (*_bfd_error_handler
)
1737 (_("%s: bad relocation section name `%s\'"),
1738 bfd_archive_filename (input_bfd
), name
);
1742 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1749 if (elf_section_data (input_section
)->stab_info
== NULL
)
1750 outrel
.r_offset
= rel
->r_offset
;
1753 off
= (_bfd_stab_section_offset
1754 (output_bfd
, htab
->root
.stab_info
, input_section
,
1755 &elf_section_data (input_section
)->stab_info
,
1757 if (off
== (bfd_vma
) -1)
1759 outrel
.r_offset
= off
;
1762 outrel
.r_offset
+= (input_section
->output_section
->vma
1763 + input_section
->output_offset
);
1767 memset (&outrel
, 0, sizeof outrel
);
1772 && (r_type
== R_386_PC32
1775 || (h
->elf_link_hash_flags
1776 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1780 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1784 /* This symbol is local, or marked to become local. */
1786 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1789 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1790 (((Elf32_External_Rel
*)
1792 + sreloc
->reloc_count
));
1793 ++sreloc
->reloc_count
;
1795 /* If this reloc is against an external symbol, we do
1796 not want to fiddle with the addend. Otherwise, we
1797 need to include the symbol value so that it becomes
1798 an addend for the dynamic reloc. */
1809 /* FIXME: Why do we allow debugging sections to escape this error?
1810 More importantly, why do we not emit dynamic relocs for
1811 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1812 If we had emitted the dynamic reloc, we could remove the
1814 if (unresolved_reloc
1816 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1817 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1818 (*_bfd_error_handler
)
1819 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1820 bfd_archive_filename (input_bfd
),
1821 bfd_get_section_name (input_bfd
, input_section
),
1822 (long) rel
->r_offset
,
1823 h
->root
.root
.string
);
1825 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1826 contents
, rel
->r_offset
,
1827 relocation
, (bfd_vma
) 0);
1834 case bfd_reloc_overflow
:
1839 name
= h
->root
.root
.string
;
1842 name
= bfd_elf_string_from_elf_section (input_bfd
,
1843 symtab_hdr
->sh_link
,
1848 name
= bfd_section_name (input_bfd
, sec
);
1850 if (! ((*info
->callbacks
->reloc_overflow
)
1851 (info
, name
, howto
->name
, (bfd_vma
) 0,
1852 input_bfd
, input_section
, rel
->r_offset
)))
1858 case bfd_reloc_outofrange
:
1867 /* Finish up dynamic symbol handling. We set the contents of various
1868 dynamic sections here. */
1871 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1873 struct bfd_link_info
*info
;
1874 struct elf_link_hash_entry
*h
;
1875 Elf_Internal_Sym
*sym
;
1877 struct elf_i386_link_hash_table
*htab
;
1880 htab
= elf_i386_hash_table (info
);
1881 dynobj
= htab
->root
.dynobj
;
1883 if (h
->plt
.offset
!= (bfd_vma
) -1)
1887 Elf_Internal_Rel rel
;
1889 /* This symbol has an entry in the procedure linkage table. Set
1892 if (h
->dynindx
== -1
1893 || htab
->splt
== NULL
1894 || htab
->sgotplt
== NULL
1895 || htab
->srelplt
== NULL
)
1898 /* Get the index in the procedure linkage table which
1899 corresponds to this symbol. This is the index of this symbol
1900 in all the symbols for which we are making plt entries. The
1901 first entry in the procedure linkage table is reserved. */
1902 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1904 /* Get the offset into the .got table of the entry that
1905 corresponds to this function. Each .got entry is 4 bytes.
1906 The first three are reserved. */
1907 got_offset
= (plt_index
+ 3) * 4;
1909 /* Fill in the entry in the procedure linkage table. */
1912 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1914 bfd_put_32 (output_bfd
,
1915 (htab
->sgotplt
->output_section
->vma
1916 + htab
->sgotplt
->output_offset
1918 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1922 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1924 bfd_put_32 (output_bfd
, got_offset
,
1925 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1928 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1929 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1930 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1931 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1933 /* Fill in the entry in the global offset table. */
1934 bfd_put_32 (output_bfd
,
1935 (htab
->splt
->output_section
->vma
1936 + htab
->splt
->output_offset
1939 htab
->sgotplt
->contents
+ got_offset
);
1941 /* Fill in the entry in the .rel.plt section. */
1942 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1943 + htab
->sgotplt
->output_offset
1945 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1946 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1947 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1950 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1952 /* Mark the symbol as undefined, rather than as defined in
1953 the .plt section. Leave the value alone. */
1954 sym
->st_shndx
= SHN_UNDEF
;
1958 if (h
->got
.offset
!= (bfd_vma
) -1)
1960 Elf_Internal_Rel rel
;
1962 /* This symbol has an entry in the global offset table. Set it
1965 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
1968 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1969 + htab
->sgot
->output_offset
1970 + (h
->got
.offset
& ~(bfd_vma
) 1));
1972 /* If this is a static link, or it is a -Bsymbolic link and the
1973 symbol is defined locally or was forced to be local because
1974 of a version file, we just want to emit a RELATIVE reloc.
1975 The entry in the global offset table will already have been
1976 initialized in the relocate_section function. */
1980 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1981 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1983 BFD_ASSERT((h
->got
.offset
& 1) != 0);
1984 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1988 BFD_ASSERT((h
->got
.offset
& 1) == 0);
1989 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1990 htab
->sgot
->contents
+ h
->got
.offset
);
1991 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
1994 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1995 ((Elf32_External_Rel
*) htab
->srelgot
->contents
1996 + htab
->srelgot
->reloc_count
));
1997 ++htab
->srelgot
->reloc_count
;
2000 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2002 Elf_Internal_Rel rel
;
2004 /* This symbol needs a copy reloc. Set it up. */
2006 if (h
->dynindx
== -1
2007 || (h
->root
.type
!= bfd_link_hash_defined
2008 && h
->root
.type
!= bfd_link_hash_defweak
)
2009 || htab
->srelbss
== NULL
)
2012 rel
.r_offset
= (h
->root
.u
.def
.value
2013 + h
->root
.u
.def
.section
->output_section
->vma
2014 + h
->root
.u
.def
.section
->output_offset
);
2015 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2016 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2017 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2018 + htab
->srelbss
->reloc_count
));
2019 ++htab
->srelbss
->reloc_count
;
2022 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2023 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2024 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2025 sym
->st_shndx
= SHN_ABS
;
2030 /* Finish up the dynamic sections. */
2033 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2035 struct bfd_link_info
*info
;
2037 struct elf_i386_link_hash_table
*htab
;
2041 htab
= elf_i386_hash_table (info
);
2042 dynobj
= htab
->root
.dynobj
;
2043 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2045 if (htab
->root
.dynamic_sections_created
)
2047 Elf32_External_Dyn
*dyncon
, *dynconend
;
2049 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2052 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2053 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2054 for (; dyncon
< dynconend
; dyncon
++)
2056 Elf_Internal_Dyn dyn
;
2058 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2066 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2067 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2071 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2072 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2076 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2077 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2079 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2080 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2084 /* My reading of the SVR4 ABI indicates that the
2085 procedure linkage table relocs (DT_JMPREL) should be
2086 included in the overall relocs (DT_REL). This is
2087 what Solaris does. However, UnixWare can not handle
2088 that case. Therefore, we override the DT_RELSZ entry
2089 here to make it not include the JMPREL relocs. Since
2090 the linker script arranges for .rel.plt to follow all
2091 other relocation sections, we don't have to worry
2092 about changing the DT_REL entry. */
2093 if (htab
->srelplt
!= NULL
)
2095 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2096 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2098 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2100 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2105 /* Fill in the first entry in the procedure linkage table. */
2106 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2109 memcpy (htab
->splt
->contents
,
2110 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2113 memcpy (htab
->splt
->contents
,
2114 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2115 bfd_put_32 (output_bfd
,
2116 (htab
->sgotplt
->output_section
->vma
2117 + htab
->sgotplt
->output_offset
2119 htab
->splt
->contents
+ 2);
2120 bfd_put_32 (output_bfd
,
2121 (htab
->sgotplt
->output_section
->vma
2122 + htab
->sgotplt
->output_offset
2124 htab
->splt
->contents
+ 8);
2127 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2128 really seem like the right value. */
2129 elf_section_data (htab
->splt
->output_section
)
2130 ->this_hdr
.sh_entsize
= 4;
2136 /* Fill in the first three entries in the global offset table. */
2137 if (htab
->sgotplt
->_raw_size
> 0)
2139 bfd_put_32 (output_bfd
,
2140 (sdyn
== NULL
? (bfd_vma
) 0
2141 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2142 htab
->sgotplt
->contents
);
2143 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2144 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2147 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2152 /* Set the correct type for an x86 ELF section. We do this by the
2153 section name, which is a hack, but ought to work. */
2156 elf_i386_fake_sections (abfd
, hdr
, sec
)
2157 bfd
*abfd ATTRIBUTE_UNUSED
;
2158 Elf32_Internal_Shdr
*hdr
;
2161 register const char *name
;
2163 name
= bfd_get_section_name (abfd
, sec
);
2165 if (strcmp (name
, ".reloc") == 0)
2167 * This is an ugly, but unfortunately necessary hack that is
2168 * needed when producing EFI binaries on x86. It tells
2169 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2170 * containing ELF relocation info. We need this hack in order to
2171 * be able to generate ELF binaries that can be translated into
2172 * EFI applications (which are essentially COFF objects). Those
2173 * files contain a COFF ".reloc" section inside an ELFNN object,
2174 * which would normally cause BFD to segfault because it would
2175 * attempt to interpret this section as containing relocation
2176 * entries for section "oc". With this hack enabled, ".reloc"
2177 * will be treated as a normal data section, which will avoid the
2178 * segfault. However, you won't be able to create an ELFNN binary
2179 * with a section named "oc" that needs relocations, but that's
2180 * the kind of ugly side-effects you get when detecting section
2181 * types based on their names... In practice, this limitation is
2184 hdr
->sh_type
= SHT_PROGBITS
;
2189 static enum elf_reloc_type_class
2190 elf_i386_reloc_type_class (rela
)
2191 const Elf_Internal_Rela
*rela
;
2193 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2195 case R_386_RELATIVE
:
2196 return reloc_class_relative
;
2197 case R_386_JUMP_SLOT
:
2198 return reloc_class_plt
;
2200 return reloc_class_copy
;
2202 return reloc_class_normal
;
2206 /* Support for core dump NOTE sections */
2208 elf_i386_grok_prstatus (abfd
, note
)
2210 Elf_Internal_Note
*note
;
2215 switch (note
->descsz
)
2220 case 144: /* Linux/i386 */
2222 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2225 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2234 /* Make a ".reg/999" section. */
2235 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2236 raw_size
, note
->descpos
+ offset
);
2240 elf_i386_grok_psinfo (abfd
, note
)
2242 Elf_Internal_Note
*note
;
2244 switch (note
->descsz
)
2249 case 128: /* Linux/MIPS elf_prpsinfo */
2250 elf_tdata (abfd
)->core_program
2251 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
2252 elf_tdata (abfd
)->core_command
2253 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
2256 /* Note that for some reason, a spurious space is tacked
2257 onto the end of the args in some (at least one anyway)
2258 implementations, so strip it off if it exists. */
2261 char *command
= elf_tdata (abfd
)->core_command
;
2262 int n
= strlen (command
);
2264 if (0 < n
&& command
[n
- 1] == ' ')
2265 command
[n
- 1] = '\0';
2271 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2272 #define TARGET_LITTLE_NAME "elf32-i386"
2273 #define ELF_ARCH bfd_arch_i386
2274 #define ELF_MACHINE_CODE EM_386
2275 #define ELF_MAXPAGESIZE 0x1000
2277 #define elf_backend_can_gc_sections 1
2278 #define elf_backend_want_got_plt 1
2279 #define elf_backend_plt_readonly 1
2280 #define elf_backend_want_plt_sym 0
2281 #define elf_backend_got_header_size 12
2282 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2284 #define elf_info_to_howto elf_i386_info_to_howto
2285 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2287 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2288 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2289 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2291 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2292 #define elf_backend_check_relocs elf_i386_check_relocs
2293 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2294 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2295 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2296 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2297 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2298 #define elf_backend_relocate_section elf_i386_relocate_section
2299 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2300 #define elf_backend_fake_sections elf_i386_fake_sections
2301 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2302 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2303 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2305 #include "elf32-target.h"