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_get_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
;
459 ret
= ((struct elf_i386_link_hash_table
*)
460 bfd_alloc (abfd
, sizeof (struct elf_i386_link_hash_table
)));
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 if (abfd
->my_archive
)
585 (*_bfd_error_handler
) (_("%s(%s): bad symbol index: %d"),
586 bfd_get_filename (abfd
->my_archive
),
587 bfd_get_filename (abfd
),
590 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
591 bfd_get_filename (abfd
),
596 if (r_symndx
< symtab_hdr
->sh_info
)
599 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
601 /* Some relocs require a global offset table. */
602 if (htab
->sgot
== NULL
)
604 switch (ELF32_R_TYPE (rel
->r_info
))
610 htab
->root
.dynobj
= dynobj
= abfd
;
611 if (!create_got_section (dynobj
, info
))
620 switch (ELF32_R_TYPE (rel
->r_info
))
623 /* This symbol requires a global offset table entry. */
626 if (h
->got
.refcount
== -1)
629 h
->got
.refcount
+= 1;
633 /* This is a global offset table entry for a local symbol. */
634 if (local_got_refcounts
== NULL
)
638 size
= symtab_hdr
->sh_info
* sizeof (bfd_signed_vma
);
639 local_got_refcounts
= ((bfd_signed_vma
*)
640 bfd_alloc (abfd
, size
));
641 if (local_got_refcounts
== NULL
)
643 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
644 memset (local_got_refcounts
, -1, size
);
646 if (local_got_refcounts
[r_symndx
] == -1)
647 local_got_refcounts
[r_symndx
] = 1;
649 local_got_refcounts
[r_symndx
] += 1;
654 /* This symbol requires a procedure linkage table entry. We
655 actually build the entry in adjust_dynamic_symbol,
656 because this might be a case of linking PIC code which is
657 never referenced by a dynamic object, in which case we
658 don't need to generate a procedure linkage table entry
661 /* If this is a local symbol, we resolve it directly without
662 creating a procedure linkage table entry. */
666 if (h
->plt
.refcount
== -1)
668 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
672 h
->plt
.refcount
+= 1;
677 if (h
!= NULL
&& !info
->shared
)
679 /* If this reloc is in a read-only section, we might
680 need a copy reloc. */
681 if ((sec
->flags
& SEC_READONLY
) != 0)
682 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
684 /* We may need a .plt entry if the function this reloc
685 refers to is in a shared lib. */
686 if (h
->plt
.refcount
== -1)
689 h
->plt
.refcount
+= 1;
692 /* If we are creating a shared library, and this is a reloc
693 against a global symbol, or a non PC relative reloc
694 against a local symbol, then we need to copy the reloc
695 into the shared library. However, if we are linking with
696 -Bsymbolic, we do not need to copy a reloc against a
697 global symbol which is defined in an object we are
698 including in the link (i.e., DEF_REGULAR is set). At
699 this point we have not seen all the input files, so it is
700 possible that DEF_REGULAR is not set now but will be set
701 later (it is never cleared). In case of a weak definition,
702 DEF_REGULAR may be cleared later by a strong definition in
703 a shared library. We account for that possibility below by
704 storing information in the relocs_copied field of the hash
705 table entry. A similar situation occurs when creating
706 shared libraries and symbol visibility changes render the
709 If on the other hand, we are creating an executable, we
710 may need to keep relocations for symbols satisfied by a
711 dynamic library if we manage to avoid copy relocs for the
714 && (sec
->flags
& SEC_ALLOC
) != 0
715 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
718 || h
->root
.type
== bfd_link_hash_defweak
719 || (h
->elf_link_hash_flags
720 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
722 && (sec
->flags
& SEC_ALLOC
) != 0
724 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
725 && (h
->root
.type
== bfd_link_hash_defweak
726 || (h
->elf_link_hash_flags
727 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
729 /* We must copy these reloc types into the output file.
730 Create a reloc section in dynobj and make room for
733 htab
->root
.dynobj
= dynobj
= abfd
;
739 name
= (bfd_elf_string_from_elf_section
741 elf_elfheader (abfd
)->e_shstrndx
,
742 elf_section_data (sec
)->rel_hdr
.sh_name
));
746 if (strncmp (name
, ".rel", 4) != 0
747 || strcmp (bfd_get_section_name (abfd
, sec
),
750 if (abfd
->my_archive
)
751 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
752 bfd_get_filename (abfd
->my_archive
),
753 bfd_get_filename (abfd
),
756 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
757 bfd_get_filename (abfd
),
761 sreloc
= bfd_get_section_by_name (dynobj
, name
);
766 sreloc
= bfd_make_section (dynobj
, name
);
767 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
768 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
769 if ((sec
->flags
& SEC_ALLOC
) != 0)
770 flags
|= SEC_ALLOC
| SEC_LOAD
;
772 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
773 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
776 if (sec
->flags
& SEC_READONLY
)
777 info
->flags
|= DF_TEXTREL
;
780 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
782 /* If this is a global symbol, we count the number of PC
783 relative relocations we have entered for this symbol,
784 so that we can discard them later as necessary. Note
785 that this function is only called if we are using an
786 elf_i386 linker hash table, which means that h is
787 really a pointer to an elf_i386_link_hash_entry. */
790 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
))
792 struct elf_i386_link_hash_entry
*eh
;
793 struct elf_i386_dyn_relocs
*p
;
795 eh
= (struct elf_i386_link_hash_entry
*) h
;
797 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
798 if (p
->section
== sreloc
)
803 p
= ((struct elf_i386_dyn_relocs
*)
804 bfd_alloc (dynobj
, sizeof *p
));
807 p
->next
= eh
->dyn_relocs
;
819 /* This relocation describes the C++ object vtable hierarchy.
820 Reconstruct it for later use during GC. */
821 case R_386_GNU_VTINHERIT
:
822 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
826 /* This relocation describes which C++ vtable entries are actually
827 used. Record for later use during GC. */
828 case R_386_GNU_VTENTRY
:
829 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
841 /* Return the section that should be marked against GC for a given
845 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
847 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
848 Elf_Internal_Rela
*rel
;
849 struct elf_link_hash_entry
*h
;
850 Elf_Internal_Sym
*sym
;
854 switch (ELF32_R_TYPE (rel
->r_info
))
856 case R_386_GNU_VTINHERIT
:
857 case R_386_GNU_VTENTRY
:
861 switch (h
->root
.type
)
863 case bfd_link_hash_defined
:
864 case bfd_link_hash_defweak
:
865 return h
->root
.u
.def
.section
;
867 case bfd_link_hash_common
:
868 return h
->root
.u
.c
.p
->section
;
877 if (!(elf_bad_symtab (abfd
)
878 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
879 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
880 && sym
->st_shndx
!= SHN_COMMON
))
882 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
889 /* Update the got entry reference counts for the section being removed. */
892 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
894 struct bfd_link_info
*info
;
896 const Elf_Internal_Rela
*relocs
;
898 Elf_Internal_Shdr
*symtab_hdr
;
899 struct elf_link_hash_entry
**sym_hashes
;
900 bfd_signed_vma
*local_got_refcounts
;
901 const Elf_Internal_Rela
*rel
, *relend
;
902 unsigned long r_symndx
;
903 struct elf_link_hash_entry
*h
;
906 dynobj
= elf_hash_table (info
)->dynobj
;
910 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
911 sym_hashes
= elf_sym_hashes (abfd
);
912 local_got_refcounts
= elf_local_got_refcounts (abfd
);
914 relend
= relocs
+ sec
->reloc_count
;
915 for (rel
= relocs
; rel
< relend
; rel
++)
916 switch (ELF32_R_TYPE (rel
->r_info
))
921 r_symndx
= ELF32_R_SYM (rel
->r_info
);
922 if (r_symndx
>= symtab_hdr
->sh_info
)
924 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
925 if (h
->got
.refcount
> 0)
926 h
->got
.refcount
-= 1;
928 else if (local_got_refcounts
!= NULL
)
930 if (local_got_refcounts
[r_symndx
] > 0)
931 local_got_refcounts
[r_symndx
] -= 1;
942 r_symndx
= ELF32_R_SYM (rel
->r_info
);
943 if (r_symndx
>= symtab_hdr
->sh_info
)
945 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
946 if (h
->plt
.refcount
> 0)
947 h
->plt
.refcount
-= 1;
958 /* Adjust a symbol defined by a dynamic object and referenced by a
959 regular object. The current definition is in some section of the
960 dynamic object, but we're not including those sections. We have to
961 change the definition to something the rest of the link can
965 elf_i386_adjust_dynamic_symbol (info
, h
)
966 struct bfd_link_info
*info
;
967 struct elf_link_hash_entry
*h
;
969 struct elf_i386_link_hash_table
*htab
;
972 unsigned int power_of_two
;
974 htab
= elf_i386_hash_table (info
);
975 dynobj
= htab
->root
.dynobj
;
977 /* If this is a function, put it in the procedure linkage table. We
978 will fill in the contents of the procedure linkage table later,
979 when we know the address of the .got section. */
980 if (h
->type
== STT_FUNC
981 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
983 if (h
->plt
.refcount
<= 0
985 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
986 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
988 /* This case can occur if we saw a PLT32 reloc in an input
989 file, but the symbol was never referred to by a dynamic
990 object, or if all references were garbage collected. In
991 such a case, we don't actually need to build a procedure
992 linkage table, and we can just do a PC32 reloc instead. */
993 h
->plt
.refcount
= (bfd_vma
) -1;
994 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1000 /* It's possible that we incorrectly decided a .plt reloc was
1001 needed for an R_386_PC32 reloc to a non-function sym in
1002 check_relocs. We can't decide accurately between function and
1003 non-function syms in check-relocs; Objects loaded later in
1004 the link may change h->type. So fix it now. */
1005 h
->plt
.refcount
= (bfd_vma
) -1;
1007 /* If this is a weak symbol, and there is a real definition, the
1008 processor independent code will have arranged for us to see the
1009 real definition first, and we can just use the same value. */
1010 if (h
->weakdef
!= NULL
)
1012 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1013 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1014 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1015 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1019 /* This is a reference to a symbol defined by a dynamic object which
1020 is not a function. */
1022 /* If we are creating a shared library, we must presume that the
1023 only references to the symbol are via the global offset table.
1024 For such cases we need not do anything here; the relocations will
1025 be handled correctly by relocate_section. */
1029 /* If there are no references to this symbol that do not use the
1030 GOT, we don't need to generate a copy reloc. */
1031 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1034 /* We must allocate the symbol in our .dynbss section, which will
1035 become part of the .bss section of the executable. There will be
1036 an entry for this symbol in the .dynsym section. The dynamic
1037 object will contain position independent code, so all references
1038 from the dynamic object to this symbol will go through the global
1039 offset table. The dynamic linker will use the .dynsym entry to
1040 determine the address it must put in the global offset table, so
1041 both the dynamic object and the regular object will refer to the
1042 same memory location for the variable. */
1048 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1049 copy the initial value out of the dynamic object and into the
1050 runtime process image. We need to remember the offset into the
1051 .rel.bss section we are going to use. */
1052 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1056 srel
= htab
->srelbss
;
1059 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1060 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1063 /* We need to figure out the alignment required for this symbol. I
1064 have no idea how ELF linkers handle this. */
1065 power_of_two
= bfd_log2 (h
->size
);
1066 if (power_of_two
> 3)
1069 /* Apply the required alignment. */
1070 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1071 (bfd_size_type
) (1 << power_of_two
));
1072 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1074 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1078 /* Define the symbol as being at this point in the section. */
1079 h
->root
.u
.def
.section
= s
;
1080 h
->root
.u
.def
.value
= s
->_raw_size
;
1082 /* Increment the section size to make room for the symbol. */
1083 s
->_raw_size
+= h
->size
;
1088 /* This is the condition under which elf_i386_finish_dynamic_symbol
1089 will be called from elflink.h. If elflink.h doesn't call our
1090 finish_dynamic_symbol routine, we'll need to do something about
1091 initializing any .plt and .got entries in elf_i386_relocate_section. */
1092 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1094 && ((INFO)->shared \
1095 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1096 && ((H)->dynindx != -1 \
1097 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1099 /* Allocate space in .plt, .got and associated reloc sections for
1100 global syms. Also discards space allocated for relocs in the
1101 check_relocs function that we subsequently have found to be
1105 allocate_plt_and_got_and_discard_relocs (h
, inf
)
1106 struct elf_link_hash_entry
*h
;
1109 struct bfd_link_info
*info
;
1110 struct elf_i386_link_hash_table
*htab
;
1112 struct elf_i386_link_hash_entry
*eh
;
1114 if (h
->root
.type
== bfd_link_hash_indirect
1115 || h
->root
.type
== bfd_link_hash_warning
)
1118 info
= (struct bfd_link_info
*) inf
;
1119 htab
= elf_i386_hash_table (info
);
1121 if (htab
->root
.dynamic_sections_created
1122 && h
->plt
.refcount
> 0)
1124 /* Make sure this symbol is output as a dynamic symbol.
1125 Undefined weak syms won't yet be marked as dynamic. */
1126 if (h
->dynindx
== -1
1127 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1129 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1137 /* If this is the first .plt entry, make room for the special
1139 if (s
->_raw_size
== 0)
1140 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1142 h
->plt
.offset
= s
->_raw_size
;
1144 /* If this symbol is not defined in a regular file, and we are
1145 not generating a shared library, then set the symbol to this
1146 location in the .plt. This is required to make function
1147 pointers compare as equal between the normal executable and
1148 the shared library. */
1150 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1152 h
->root
.u
.def
.section
= s
;
1153 h
->root
.u
.def
.value
= h
->plt
.offset
;
1156 /* Make room for this entry. */
1157 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1159 /* We also need to make an entry in the .got.plt section, which
1160 will be placed in the .got section by the linker script. */
1166 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1168 /* We also need to make an entry in the .rel.plt section. */
1172 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1177 h
->plt
.offset
= (bfd_vma
) -1;
1178 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1181 if (h
->got
.refcount
> 0)
1185 /* Make sure this symbol is output as a dynamic symbol.
1186 Undefined weak syms won't yet be marked as dynamic. */
1187 if (h
->dynindx
== -1
1188 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1190 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1195 h
->got
.offset
= s
->_raw_size
;
1197 dyn
= htab
->root
.dynamic_sections_created
;
1198 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1199 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1202 h
->got
.offset
= (bfd_vma
) -1;
1204 /* In the shared -Bsymbolic case, discard space allocated for
1205 dynamic relocs against symbols which turn out to be defined
1206 in regular objects. For the normal shared case, discard space
1207 for relocs that have become local due to symbol visibility
1208 changes. For the non-shared case, discard space for symbols
1209 which turn out to need copy relocs or are not dynamic. */
1211 eh
= (struct elf_i386_link_hash_entry
*) h
;
1212 if (eh
->dyn_relocs
== NULL
)
1216 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1217 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1218 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1219 || (htab
->root
.dynamic_sections_created
1220 && (h
->root
.type
== bfd_link_hash_undefweak
1221 || h
->root
.type
== bfd_link_hash_undefined
))))
1223 /* Make sure this symbol is output as a dynamic symbol.
1224 Undefined weak syms won't yet be marked as dynamic. */
1225 if (h
->dynindx
== -1
1226 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1228 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1232 /* If that succeeded, we know we'll be keeping all the relocs. */
1233 if (h
->dynindx
!= -1)
1238 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1239 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1240 || info
->symbolic
)))
1242 struct elf_i386_dyn_relocs
*c
;
1244 for (c
= eh
->dyn_relocs
; c
!= NULL
; c
= c
->next
)
1245 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1251 /* Set the sizes of the dynamic sections. */
1254 elf_i386_size_dynamic_sections (output_bfd
, info
)
1255 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1256 struct bfd_link_info
*info
;
1258 struct elf_i386_link_hash_table
*htab
;
1264 htab
= elf_i386_hash_table (info
);
1265 dynobj
= htab
->root
.dynobj
;
1269 if (htab
->root
.dynamic_sections_created
)
1271 /* Set the contents of the .interp section to the interpreter. */
1274 s
= bfd_get_section_by_name (dynobj
, ".interp");
1277 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1278 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1282 /* Set up .got offsets for local syms. */
1283 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1285 bfd_signed_vma
*local_got
;
1286 bfd_signed_vma
*end_local_got
;
1287 bfd_size_type locsymcount
;
1288 Elf_Internal_Shdr
*symtab_hdr
;
1291 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1294 local_got
= elf_local_got_refcounts (i
);
1298 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1299 locsymcount
= symtab_hdr
->sh_info
;
1300 end_local_got
= local_got
+ locsymcount
;
1302 srel
= htab
->srelgot
;
1303 for (; local_got
< end_local_got
; ++local_got
)
1307 *local_got
= s
->_raw_size
;
1310 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1313 *local_got
= (bfd_vma
) -1;
1317 /* Allocate global sym .plt and .got entries. Also discard all
1319 elf_link_hash_traverse (&htab
->root
,
1320 allocate_plt_and_got_and_discard_relocs
,
1323 /* We now have determined the sizes of the various dynamic sections.
1324 Allocate memory for them. */
1326 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1328 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1333 || s
== htab
->sgotplt
)
1335 /* Strip this section if we don't need it; see the
1338 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1340 if (s
->_raw_size
== 0)
1342 /* If we don't need this section, strip it from the
1343 output file. This is mostly to handle .rel.bss and
1344 .rel.plt. We must create both sections in
1345 create_dynamic_sections, because they must be created
1346 before the linker maps input sections to output
1347 sections. The linker does that before
1348 adjust_dynamic_symbol is called, and it is that
1349 function which decides whether anything needs to go
1350 into these sections. */
1354 if (s
!= htab
->srelplt
)
1357 /* We use the reloc_count field as a counter if we need
1358 to copy relocs into the output file. */
1364 /* It's not one of our sections, so don't allocate space. */
1368 if (s
->_raw_size
== 0)
1370 _bfd_strip_section_from_output (info
, s
);
1374 /* Allocate memory for the section contents. We use bfd_zalloc
1375 here in case unused entries are not reclaimed before the
1376 section's contents are written out. This should not happen,
1377 but this way if it does, we get a R_386_NONE reloc instead
1379 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1380 if (s
->contents
== NULL
)
1384 if (htab
->root
.dynamic_sections_created
)
1386 /* Add some entries to the .dynamic section. We fill in the
1387 values later, in elf_i386_finish_dynamic_sections, but we
1388 must add the entries now so that we get the correct size for
1389 the .dynamic section. The DT_DEBUG entry is filled in by the
1390 dynamic linker and used by the debugger. */
1393 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
1397 if (htab
->splt
->_raw_size
!= 0)
1399 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1400 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1401 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
1402 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
1408 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
1409 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
1410 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
1411 sizeof (Elf32_External_Rel
)))
1415 if ((info
->flags
& DF_TEXTREL
) != 0)
1417 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1425 /* Relocate an i386 ELF section. */
1428 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1429 contents
, relocs
, local_syms
, local_sections
)
1431 struct bfd_link_info
*info
;
1433 asection
*input_section
;
1435 Elf_Internal_Rela
*relocs
;
1436 Elf_Internal_Sym
*local_syms
;
1437 asection
**local_sections
;
1439 struct elf_i386_link_hash_table
*htab
;
1441 Elf_Internal_Shdr
*symtab_hdr
;
1442 struct elf_link_hash_entry
**sym_hashes
;
1443 bfd_vma
*local_got_offsets
;
1445 Elf_Internal_Rela
*rel
;
1446 Elf_Internal_Rela
*relend
;
1448 htab
= elf_i386_hash_table (info
);
1449 dynobj
= htab
->root
.dynobj
;
1450 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1451 sym_hashes
= elf_sym_hashes (input_bfd
);
1452 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1456 relend
= relocs
+ input_section
->reloc_count
;
1457 for (; rel
< relend
; rel
++)
1460 reloc_howto_type
*howto
;
1461 unsigned long r_symndx
;
1462 struct elf_link_hash_entry
*h
;
1463 Elf_Internal_Sym
*sym
;
1467 boolean unresolved_reloc
;
1468 bfd_reloc_status_type r
;
1471 r_type
= ELF32_R_TYPE (rel
->r_info
);
1472 if (r_type
== (int) R_386_GNU_VTINHERIT
1473 || r_type
== (int) R_386_GNU_VTENTRY
)
1476 if ((indx
= (unsigned) r_type
) >= R_386_standard
1477 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1478 >= R_386_ext
- R_386_standard
))
1480 bfd_set_error (bfd_error_bad_value
);
1483 howto
= elf_howto_table
+ indx
;
1485 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1487 if (info
->relocateable
)
1489 /* This is a relocateable link. We don't have to change
1490 anything, unless the reloc is against a section symbol,
1491 in which case we have to adjust according to where the
1492 section symbol winds up in the output section. */
1493 if (r_symndx
< symtab_hdr
->sh_info
)
1495 sym
= local_syms
+ r_symndx
;
1496 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1500 sec
= local_sections
[r_symndx
];
1501 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1502 val
+= sec
->output_offset
+ sym
->st_value
;
1503 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1510 /* This is a final link. */
1514 unresolved_reloc
= false;
1515 if (r_symndx
< symtab_hdr
->sh_info
)
1517 sym
= local_syms
+ r_symndx
;
1518 sec
= local_sections
[r_symndx
];
1519 relocation
= (sec
->output_section
->vma
1520 + sec
->output_offset
1525 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1526 while (h
->root
.type
== bfd_link_hash_indirect
1527 || h
->root
.type
== bfd_link_hash_warning
)
1528 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1531 if (h
->root
.type
== bfd_link_hash_defined
1532 || h
->root
.type
== bfd_link_hash_defweak
)
1534 sec
= h
->root
.u
.def
.section
;
1535 if (sec
->output_section
== NULL
)
1536 /* Set a flag that will be cleared later if we find a
1537 relocation value for this symbol. output_section
1538 is typically NULL for symbols satisfied by a shared
1540 unresolved_reloc
= true;
1542 relocation
= (h
->root
.u
.def
.value
1543 + sec
->output_section
->vma
1544 + sec
->output_offset
);
1546 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1548 else if (info
->shared
&& !info
->symbolic
1549 && !info
->no_undefined
1550 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1554 if (! ((*info
->callbacks
->undefined_symbol
)
1555 (info
, h
->root
.root
.string
, input_bfd
,
1556 input_section
, rel
->r_offset
,
1557 (!info
->shared
|| info
->no_undefined
1558 || ELF_ST_VISIBILITY (h
->other
)))))
1566 /* Relocation is to the entry for this symbol in the global
1568 if (htab
->sgot
== NULL
)
1575 off
= h
->got
.offset
;
1576 dyn
= htab
->root
.dynamic_sections_created
;
1577 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1581 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1582 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1584 /* This is actually a static link, or it is a
1585 -Bsymbolic link and the symbol is defined
1586 locally, or the symbol was forced to be local
1587 because of a version file. We must initialize
1588 this entry in the global offset table. Since the
1589 offset must always be a multiple of 4, we use the
1590 least significant bit to record whether we have
1591 initialized it already.
1593 When doing a dynamic link, we create a .rel.got
1594 relocation entry to initialize the value. This
1595 is done in the finish_dynamic_symbol routine. */
1600 bfd_put_32 (output_bfd
, relocation
,
1601 htab
->sgot
->contents
+ off
);
1606 unresolved_reloc
= false;
1610 if (local_got_offsets
== NULL
)
1613 off
= local_got_offsets
[r_symndx
];
1615 /* The offset must always be a multiple of 4. We use
1616 the least significant bit to record whether we have
1617 already generated the necessary reloc. */
1622 bfd_put_32 (output_bfd
, relocation
,
1623 htab
->sgot
->contents
+ off
);
1628 Elf_Internal_Rel outrel
;
1630 srelgot
= htab
->srelgot
;
1631 if (srelgot
== NULL
)
1634 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1635 + htab
->sgot
->output_offset
1637 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1638 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1639 (((Elf32_External_Rel
*)
1641 + srelgot
->reloc_count
));
1642 ++srelgot
->reloc_count
;
1645 local_got_offsets
[r_symndx
] |= 1;
1649 if (off
>= (bfd_vma
) -2)
1652 relocation
= htab
->sgot
->output_offset
+ off
;
1656 /* Relocation is relative to the start of the global offset
1659 /* Note that sgot->output_offset is not involved in this
1660 calculation. We always want the start of .got. If we
1661 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1662 permitted by the ABI, we might have to change this
1664 relocation
-= htab
->sgot
->output_section
->vma
;
1668 /* Use global offset table as symbol value. */
1669 relocation
= htab
->sgot
->output_section
->vma
;
1670 unresolved_reloc
= false;
1674 /* Relocation is to the entry for this symbol in the
1675 procedure linkage table. */
1677 /* Resolve a PLT32 reloc against a local symbol directly,
1678 without using the procedure linkage table. */
1682 if (h
->plt
.offset
== (bfd_vma
) -1
1683 || htab
->splt
== NULL
)
1685 /* We didn't make a PLT entry for this symbol. This
1686 happens when statically linking PIC code, or when
1687 using -Bsymbolic. */
1691 relocation
= (htab
->splt
->output_section
->vma
1692 + htab
->splt
->output_offset
1694 unresolved_reloc
= false;
1700 && (input_section
->flags
& SEC_ALLOC
) != 0
1701 && (r_type
!= R_386_PC32
1704 && (! info
->symbolic
1705 || (h
->elf_link_hash_flags
1706 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1708 && (input_section
->flags
& SEC_ALLOC
) != 0
1711 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1712 && (((h
->elf_link_hash_flags
1713 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1714 && (h
->elf_link_hash_flags
1715 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1716 || h
->root
.type
== bfd_link_hash_undefweak
1717 || h
->root
.type
== bfd_link_hash_undefined
)))
1719 Elf_Internal_Rel outrel
;
1720 boolean skip
, relocate
;
1722 /* When generating a shared object, these relocations
1723 are copied into the output file to be resolved at run
1730 name
= (bfd_elf_string_from_elf_section
1732 elf_elfheader (input_bfd
)->e_shstrndx
,
1733 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1737 if (strncmp (name
, ".rel", 4) != 0
1738 || strcmp (bfd_get_section_name (input_bfd
,
1742 if (input_bfd
->my_archive
)
1743 (*_bfd_error_handler
)\
1744 (_("%s(%s): bad relocation section name `%s\'"),
1745 bfd_get_filename (input_bfd
->my_archive
),
1746 bfd_get_filename (input_bfd
),
1749 (*_bfd_error_handler
)
1750 (_("%s: bad relocation section name `%s\'"),
1751 bfd_get_filename (input_bfd
),
1756 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1763 if (elf_section_data (input_section
)->stab_info
== NULL
)
1764 outrel
.r_offset
= rel
->r_offset
;
1769 off
= (_bfd_stab_section_offset
1770 (output_bfd
, htab
->root
.stab_info
, input_section
,
1771 &elf_section_data (input_section
)->stab_info
,
1773 if (off
== (bfd_vma
) -1)
1775 outrel
.r_offset
= off
;
1778 outrel
.r_offset
+= (input_section
->output_section
->vma
1779 + input_section
->output_offset
);
1783 memset (&outrel
, 0, sizeof outrel
);
1788 && (r_type
== R_386_PC32
1791 || (h
->elf_link_hash_flags
1792 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1796 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1800 /* This symbol is local, or marked to become local. */
1802 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1805 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1806 (((Elf32_External_Rel
*)
1808 + sreloc
->reloc_count
));
1809 ++sreloc
->reloc_count
;
1811 /* If this reloc is against an external symbol, we do
1812 not want to fiddle with the addend. Otherwise, we
1813 need to include the symbol value so that it becomes
1814 an addend for the dynamic reloc. */
1825 /* FIXME: Why do we allow debugging sections to escape this error?
1826 More importantly, why do we not emit dynamic relocs for
1827 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1828 If we had emitted the dynamic reloc, we could remove the
1830 if (unresolved_reloc
1832 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1833 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1834 (*_bfd_error_handler
)
1835 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1836 bfd_get_filename (input_bfd
),
1837 bfd_get_section_name (input_bfd
, input_section
),
1838 (long) rel
->r_offset
,
1839 h
->root
.root
.string
);
1841 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1842 contents
, rel
->r_offset
,
1843 relocation
, (bfd_vma
) 0);
1850 case bfd_reloc_overflow
:
1855 name
= h
->root
.root
.string
;
1858 name
= bfd_elf_string_from_elf_section (input_bfd
,
1859 symtab_hdr
->sh_link
,
1864 name
= bfd_section_name (input_bfd
, sec
);
1866 if (! ((*info
->callbacks
->reloc_overflow
)
1867 (info
, name
, howto
->name
, (bfd_vma
) 0,
1868 input_bfd
, input_section
, rel
->r_offset
)))
1874 case bfd_reloc_outofrange
:
1883 /* Finish up dynamic symbol handling. We set the contents of various
1884 dynamic sections here. */
1887 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1889 struct bfd_link_info
*info
;
1890 struct elf_link_hash_entry
*h
;
1891 Elf_Internal_Sym
*sym
;
1893 struct elf_i386_link_hash_table
*htab
;
1896 htab
= elf_i386_hash_table (info
);
1897 dynobj
= htab
->root
.dynobj
;
1899 if (h
->plt
.offset
!= (bfd_vma
) -1)
1903 Elf_Internal_Rel rel
;
1905 /* This symbol has an entry in the procedure linkage table. Set
1908 if (h
->dynindx
== -1
1909 || htab
->splt
== NULL
1910 || htab
->sgotplt
== NULL
1911 || htab
->srelplt
== NULL
)
1914 /* Get the index in the procedure linkage table which
1915 corresponds to this symbol. This is the index of this symbol
1916 in all the symbols for which we are making plt entries. The
1917 first entry in the procedure linkage table is reserved. */
1918 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1920 /* Get the offset into the .got table of the entry that
1921 corresponds to this function. Each .got entry is 4 bytes.
1922 The first three are reserved. */
1923 got_offset
= (plt_index
+ 3) * 4;
1925 /* Fill in the entry in the procedure linkage table. */
1928 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1930 bfd_put_32 (output_bfd
,
1931 (htab
->sgotplt
->output_section
->vma
1932 + htab
->sgotplt
->output_offset
1934 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1938 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1940 bfd_put_32 (output_bfd
, got_offset
,
1941 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1944 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1945 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1946 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1947 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1949 /* Fill in the entry in the global offset table. */
1950 bfd_put_32 (output_bfd
,
1951 (htab
->splt
->output_section
->vma
1952 + htab
->splt
->output_offset
1955 htab
->sgotplt
->contents
+ got_offset
);
1957 /* Fill in the entry in the .rel.plt section. */
1958 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1959 + htab
->sgotplt
->output_offset
1961 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1962 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1963 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1966 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1968 /* Mark the symbol as undefined, rather than as defined in
1969 the .plt section. Leave the value alone. */
1970 sym
->st_shndx
= SHN_UNDEF
;
1974 if (h
->got
.offset
!= (bfd_vma
) -1)
1976 Elf_Internal_Rel rel
;
1978 /* This symbol has an entry in the global offset table. Set it
1981 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
1984 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1985 + htab
->sgot
->output_offset
1986 + (h
->got
.offset
&~ 1));
1988 /* If this is a static link, or it is a -Bsymbolic link and the
1989 symbol is defined locally or was forced to be local because
1990 of a version file, we just want to emit a RELATIVE reloc.
1991 The entry in the global offset table will already have been
1992 initialized in the relocate_section function. */
1996 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1997 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1999 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2000 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2004 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2005 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2006 htab
->sgot
->contents
+ h
->got
.offset
);
2007 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2010 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2011 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2012 + htab
->srelgot
->reloc_count
));
2013 ++htab
->srelgot
->reloc_count
;
2016 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2018 Elf_Internal_Rel rel
;
2020 /* This symbol needs a copy reloc. Set it up. */
2022 if (h
->dynindx
== -1
2023 || (h
->root
.type
!= bfd_link_hash_defined
2024 && h
->root
.type
!= bfd_link_hash_defweak
)
2025 || htab
->srelbss
== NULL
)
2028 rel
.r_offset
= (h
->root
.u
.def
.value
2029 + h
->root
.u
.def
.section
->output_section
->vma
2030 + h
->root
.u
.def
.section
->output_offset
);
2031 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2032 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2033 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2034 + htab
->srelbss
->reloc_count
));
2035 ++htab
->srelbss
->reloc_count
;
2038 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2039 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2040 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2041 sym
->st_shndx
= SHN_ABS
;
2046 /* Finish up the dynamic sections. */
2049 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2051 struct bfd_link_info
*info
;
2053 struct elf_i386_link_hash_table
*htab
;
2057 htab
= elf_i386_hash_table (info
);
2058 dynobj
= htab
->root
.dynobj
;
2059 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2061 if (htab
->root
.dynamic_sections_created
)
2063 Elf32_External_Dyn
*dyncon
, *dynconend
;
2065 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2068 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2069 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2070 for (; dyncon
< dynconend
; dyncon
++)
2072 Elf_Internal_Dyn dyn
;
2074 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2082 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2083 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2087 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2088 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2092 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2093 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2095 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2096 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2100 /* My reading of the SVR4 ABI indicates that the
2101 procedure linkage table relocs (DT_JMPREL) should be
2102 included in the overall relocs (DT_REL). This is
2103 what Solaris does. However, UnixWare can not handle
2104 that case. Therefore, we override the DT_RELSZ entry
2105 here to make it not include the JMPREL relocs. Since
2106 the linker script arranges for .rel.plt to follow all
2107 other relocation sections, we don't have to worry
2108 about changing the DT_REL entry. */
2109 if (htab
->srelplt
!= NULL
)
2111 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2112 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2114 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2116 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2121 /* Fill in the first entry in the procedure linkage table. */
2122 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2125 memcpy (htab
->splt
->contents
,
2126 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2129 memcpy (htab
->splt
->contents
,
2130 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2131 bfd_put_32 (output_bfd
,
2132 (htab
->sgotplt
->output_section
->vma
2133 + htab
->sgotplt
->output_offset
2135 htab
->splt
->contents
+ 2);
2136 bfd_put_32 (output_bfd
,
2137 (htab
->sgotplt
->output_section
->vma
2138 + htab
->sgotplt
->output_offset
2140 htab
->splt
->contents
+ 8);
2143 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2144 really seem like the right value. */
2145 elf_section_data (htab
->splt
->output_section
)
2146 ->this_hdr
.sh_entsize
= 4;
2152 /* Fill in the first three entries in the global offset table. */
2153 if (htab
->sgotplt
->_raw_size
> 0)
2155 bfd_put_32 (output_bfd
,
2156 (sdyn
== NULL
? (bfd_vma
) 0
2157 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2158 htab
->sgotplt
->contents
);
2159 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2160 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2163 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2168 /* Set the correct type for an x86 ELF section. We do this by the
2169 section name, which is a hack, but ought to work. */
2172 elf_i386_fake_sections (abfd
, hdr
, sec
)
2173 bfd
*abfd ATTRIBUTE_UNUSED
;
2174 Elf32_Internal_Shdr
*hdr
;
2177 register const char *name
;
2179 name
= bfd_get_section_name (abfd
, sec
);
2181 if (strcmp (name
, ".reloc") == 0)
2183 * This is an ugly, but unfortunately necessary hack that is
2184 * needed when producing EFI binaries on x86. It tells
2185 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2186 * containing ELF relocation info. We need this hack in order to
2187 * be able to generate ELF binaries that can be translated into
2188 * EFI applications (which are essentially COFF objects). Those
2189 * files contain a COFF ".reloc" section inside an ELFNN object,
2190 * which would normally cause BFD to segfault because it would
2191 * attempt to interpret this section as containing relocation
2192 * entries for section "oc". With this hack enabled, ".reloc"
2193 * will be treated as a normal data section, which will avoid the
2194 * segfault. However, you won't be able to create an ELFNN binary
2195 * with a section named "oc" that needs relocations, but that's
2196 * the kind of ugly side-effects you get when detecting section
2197 * types based on their names... In practice, this limitation is
2200 hdr
->sh_type
= SHT_PROGBITS
;
2205 static enum elf_reloc_type_class
2206 elf_i386_reloc_type_class (type
)
2211 case R_386_RELATIVE
:
2212 return reloc_class_relative
;
2213 case R_386_JUMP_SLOT
:
2214 return reloc_class_plt
;
2216 return reloc_class_copy
;
2218 return reloc_class_normal
;
2222 /* Support for core dump NOTE sections */
2224 elf_i386_grok_prstatus (abfd
, note
)
2226 Elf_Internal_Note
*note
;
2231 switch (note
->descsz
)
2236 case 144: /* Linux/i386 */
2238 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2241 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2250 /* Make a ".reg/999" section. */
2251 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2252 raw_size
, note
->descpos
+ offset
);
2256 elf_i386_grok_psinfo (abfd
, note
)
2258 Elf_Internal_Note
*note
;
2260 switch (note
->descsz
)
2265 case 128: /* Linux/MIPS elf_prpsinfo */
2266 elf_tdata (abfd
)->core_program
2267 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
2268 elf_tdata (abfd
)->core_command
2269 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
2272 /* Note that for some reason, a spurious space is tacked
2273 onto the end of the args in some (at least one anyway)
2274 implementations, so strip it off if it exists. */
2277 char *command
= elf_tdata (abfd
)->core_command
;
2278 int n
= strlen (command
);
2280 if (0 < n
&& command
[n
- 1] == ' ')
2281 command
[n
- 1] = '\0';
2287 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2288 #define TARGET_LITTLE_NAME "elf32-i386"
2289 #define ELF_ARCH bfd_arch_i386
2290 #define ELF_MACHINE_CODE EM_386
2291 #define ELF_MAXPAGESIZE 0x1000
2293 #define elf_backend_can_gc_sections 1
2294 #define elf_backend_want_got_plt 1
2295 #define elf_backend_plt_readonly 1
2296 #define elf_backend_want_plt_sym 0
2297 #define elf_backend_got_header_size 12
2298 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2300 #define elf_info_to_howto elf_i386_info_to_howto
2301 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2303 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2304 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2305 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2307 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2308 #define elf_backend_check_relocs elf_i386_check_relocs
2309 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2310 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2311 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2312 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2313 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2314 #define elf_backend_relocate_section elf_i386_relocate_section
2315 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2316 #define elf_backend_fake_sections elf_i386_fake_sections
2317 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2318 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2319 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2321 #include "elf32-target.h"