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
;
458 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
460 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
461 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
464 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
465 elf_i386_link_hash_newfunc
))
467 bfd_release (abfd
, ret
);
479 return &ret
->root
.root
;
482 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
483 shortcuts to them in our hash table. */
486 create_got_section (dynobj
, info
)
488 struct bfd_link_info
*info
;
490 struct elf_i386_link_hash_table
*htab
;
492 if (! _bfd_elf_create_got_section (dynobj
, info
))
495 htab
= elf_i386_hash_table (info
);
496 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
497 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
498 if (!htab
->sgot
|| !htab
->sgotplt
)
501 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
502 if (htab
->srelgot
== NULL
503 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
504 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
505 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
507 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
512 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
513 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
517 elf_i386_create_dynamic_sections (dynobj
, info
)
519 struct bfd_link_info
*info
;
521 struct elf_i386_link_hash_table
*htab
;
523 htab
= elf_i386_hash_table (info
);
524 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
527 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
530 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
531 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
532 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
534 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
536 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
537 || (!info
->shared
&& !htab
->srelbss
))
543 /* Look through the relocs for a section during the first phase, and
544 allocate space in the global offset table or procedure linkage
548 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
550 struct bfd_link_info
*info
;
552 const Elf_Internal_Rela
*relocs
;
554 struct elf_i386_link_hash_table
*htab
;
556 Elf_Internal_Shdr
*symtab_hdr
;
557 struct elf_link_hash_entry
**sym_hashes
;
558 bfd_signed_vma
*local_got_refcounts
;
559 const Elf_Internal_Rela
*rel
;
560 const Elf_Internal_Rela
*rel_end
;
563 if (info
->relocateable
)
566 htab
= elf_i386_hash_table (info
);
567 dynobj
= htab
->root
.dynobj
;
568 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
569 sym_hashes
= elf_sym_hashes (abfd
);
570 local_got_refcounts
= elf_local_got_refcounts (abfd
);
574 rel_end
= relocs
+ sec
->reloc_count
;
575 for (rel
= relocs
; rel
< rel_end
; rel
++)
577 unsigned long r_symndx
;
578 struct elf_link_hash_entry
*h
;
580 r_symndx
= ELF32_R_SYM (rel
->r_info
);
582 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
584 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
;
639 size
*= sizeof (bfd_signed_vma
);
640 local_got_refcounts
= ((bfd_signed_vma
*)
641 bfd_alloc (abfd
, size
));
642 if (local_got_refcounts
== NULL
)
644 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
645 memset (local_got_refcounts
, -1, (size_t) size
);
647 if (local_got_refcounts
[r_symndx
] == -1)
648 local_got_refcounts
[r_symndx
] = 1;
650 local_got_refcounts
[r_symndx
] += 1;
655 /* This symbol requires a procedure linkage table entry. We
656 actually build the entry in adjust_dynamic_symbol,
657 because this might be a case of linking PIC code which is
658 never referenced by a dynamic object, in which case we
659 don't need to generate a procedure linkage table entry
662 /* If this is a local symbol, we resolve it directly without
663 creating a procedure linkage table entry. */
667 if (h
->plt
.refcount
== -1)
669 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
673 h
->plt
.refcount
+= 1;
678 if (h
!= NULL
&& !info
->shared
)
680 /* If this reloc is in a read-only section, we might
681 need a copy reloc. */
682 if ((sec
->flags
& SEC_READONLY
) != 0)
683 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
685 /* We may need a .plt entry if the function this reloc
686 refers to is in a shared lib. */
687 if (h
->plt
.refcount
== -1)
690 h
->plt
.refcount
+= 1;
693 /* If we are creating a shared library, and this is a reloc
694 against a global symbol, or a non PC relative reloc
695 against a local symbol, then we need to copy the reloc
696 into the shared library. However, if we are linking with
697 -Bsymbolic, we do not need to copy a reloc against a
698 global symbol which is defined in an object we are
699 including in the link (i.e., DEF_REGULAR is set). At
700 this point we have not seen all the input files, so it is
701 possible that DEF_REGULAR is not set now but will be set
702 later (it is never cleared). In case of a weak definition,
703 DEF_REGULAR may be cleared later by a strong definition in
704 a shared library. We account for that possibility below by
705 storing information in the relocs_copied field of the hash
706 table entry. A similar situation occurs when creating
707 shared libraries and symbol visibility changes render the
710 If on the other hand, we are creating an executable, we
711 may need to keep relocations for symbols satisfied by a
712 dynamic library if we manage to avoid copy relocs for the
715 && (sec
->flags
& SEC_ALLOC
) != 0
716 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
719 || h
->root
.type
== bfd_link_hash_defweak
720 || (h
->elf_link_hash_flags
721 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
723 && (sec
->flags
& SEC_ALLOC
) != 0
725 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
726 && (h
->root
.type
== bfd_link_hash_defweak
727 || (h
->elf_link_hash_flags
728 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
730 /* We must copy these reloc types into the output file.
731 Create a reloc section in dynobj and make room for
734 htab
->root
.dynobj
= dynobj
= abfd
;
740 name
= (bfd_elf_string_from_elf_section
742 elf_elfheader (abfd
)->e_shstrndx
,
743 elf_section_data (sec
)->rel_hdr
.sh_name
));
747 if (strncmp (name
, ".rel", 4) != 0
748 || strcmp (bfd_get_section_name (abfd
, sec
),
751 if (abfd
->my_archive
)
752 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
753 bfd_get_filename (abfd
->my_archive
),
754 bfd_get_filename (abfd
),
757 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
758 bfd_get_filename (abfd
),
762 sreloc
= bfd_get_section_by_name (dynobj
, name
);
767 sreloc
= bfd_make_section (dynobj
, name
);
768 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
769 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
770 if ((sec
->flags
& SEC_ALLOC
) != 0)
771 flags
|= SEC_ALLOC
| SEC_LOAD
;
773 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
774 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
777 if (sec
->flags
& SEC_READONLY
)
778 info
->flags
|= DF_TEXTREL
;
781 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
783 /* If this is a global symbol, we count the number of PC
784 relative relocations we have entered for this symbol,
785 so that we can discard them later as necessary. Note
786 that this function is only called if we are using an
787 elf_i386 linker hash table, which means that h is
788 really a pointer to an elf_i386_link_hash_entry. */
791 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
))
793 struct elf_i386_link_hash_entry
*eh
;
794 struct elf_i386_dyn_relocs
*p
;
796 eh
= (struct elf_i386_link_hash_entry
*) h
;
798 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
799 if (p
->section
== sreloc
)
804 p
= ((struct elf_i386_dyn_relocs
*)
805 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
808 p
->next
= eh
->dyn_relocs
;
820 /* This relocation describes the C++ object vtable hierarchy.
821 Reconstruct it for later use during GC. */
822 case R_386_GNU_VTINHERIT
:
823 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
827 /* This relocation describes which C++ vtable entries are actually
828 used. Record for later use during GC. */
829 case R_386_GNU_VTENTRY
:
830 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
842 /* Return the section that should be marked against GC for a given
846 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
848 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
849 Elf_Internal_Rela
*rel
;
850 struct elf_link_hash_entry
*h
;
851 Elf_Internal_Sym
*sym
;
855 switch (ELF32_R_TYPE (rel
->r_info
))
857 case R_386_GNU_VTINHERIT
:
858 case R_386_GNU_VTENTRY
:
862 switch (h
->root
.type
)
864 case bfd_link_hash_defined
:
865 case bfd_link_hash_defweak
:
866 return h
->root
.u
.def
.section
;
868 case bfd_link_hash_common
:
869 return h
->root
.u
.c
.p
->section
;
878 if (!(elf_bad_symtab (abfd
)
879 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
880 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
881 && sym
->st_shndx
!= SHN_COMMON
))
883 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
890 /* Update the got entry reference counts for the section being removed. */
893 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
895 struct bfd_link_info
*info
;
897 const Elf_Internal_Rela
*relocs
;
899 Elf_Internal_Shdr
*symtab_hdr
;
900 struct elf_link_hash_entry
**sym_hashes
;
901 bfd_signed_vma
*local_got_refcounts
;
902 const Elf_Internal_Rela
*rel
, *relend
;
903 unsigned long r_symndx
;
904 struct elf_link_hash_entry
*h
;
907 dynobj
= elf_hash_table (info
)->dynobj
;
911 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
912 sym_hashes
= elf_sym_hashes (abfd
);
913 local_got_refcounts
= elf_local_got_refcounts (abfd
);
915 relend
= relocs
+ sec
->reloc_count
;
916 for (rel
= relocs
; rel
< relend
; rel
++)
917 switch (ELF32_R_TYPE (rel
->r_info
))
922 r_symndx
= ELF32_R_SYM (rel
->r_info
);
923 if (r_symndx
>= symtab_hdr
->sh_info
)
925 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
926 if (h
->got
.refcount
> 0)
927 h
->got
.refcount
-= 1;
929 else if (local_got_refcounts
!= NULL
)
931 if (local_got_refcounts
[r_symndx
] > 0)
932 local_got_refcounts
[r_symndx
] -= 1;
943 r_symndx
= ELF32_R_SYM (rel
->r_info
);
944 if (r_symndx
>= symtab_hdr
->sh_info
)
946 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
947 if (h
->plt
.refcount
> 0)
948 h
->plt
.refcount
-= 1;
959 /* Adjust a symbol defined by a dynamic object and referenced by a
960 regular object. The current definition is in some section of the
961 dynamic object, but we're not including those sections. We have to
962 change the definition to something the rest of the link can
966 elf_i386_adjust_dynamic_symbol (info
, h
)
967 struct bfd_link_info
*info
;
968 struct elf_link_hash_entry
*h
;
970 struct elf_i386_link_hash_table
*htab
;
973 unsigned int power_of_two
;
975 htab
= elf_i386_hash_table (info
);
976 dynobj
= htab
->root
.dynobj
;
978 /* If this is a function, put it in the procedure linkage table. We
979 will fill in the contents of the procedure linkage table later,
980 when we know the address of the .got section. */
981 if (h
->type
== STT_FUNC
982 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
984 if (h
->plt
.refcount
<= 0
986 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
987 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
989 /* This case can occur if we saw a PLT32 reloc in an input
990 file, but the symbol was never referred to by a dynamic
991 object, or if all references were garbage collected. In
992 such a case, we don't actually need to build a procedure
993 linkage table, and we can just do a PC32 reloc instead. */
994 h
->plt
.refcount
= (bfd_vma
) -1;
995 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1001 /* It's possible that we incorrectly decided a .plt reloc was
1002 needed for an R_386_PC32 reloc to a non-function sym in
1003 check_relocs. We can't decide accurately between function and
1004 non-function syms in check-relocs; Objects loaded later in
1005 the link may change h->type. So fix it now. */
1006 h
->plt
.refcount
= (bfd_vma
) -1;
1008 /* If this is a weak symbol, and there is a real definition, the
1009 processor independent code will have arranged for us to see the
1010 real definition first, and we can just use the same value. */
1011 if (h
->weakdef
!= NULL
)
1013 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1014 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1015 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1016 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1020 /* This is a reference to a symbol defined by a dynamic object which
1021 is not a function. */
1023 /* If we are creating a shared library, we must presume that the
1024 only references to the symbol are via the global offset table.
1025 For such cases we need not do anything here; the relocations will
1026 be handled correctly by relocate_section. */
1030 /* If there are no references to this symbol that do not use the
1031 GOT, we don't need to generate a copy reloc. */
1032 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1035 /* We must allocate the symbol in our .dynbss section, which will
1036 become part of the .bss section of the executable. There will be
1037 an entry for this symbol in the .dynsym section. The dynamic
1038 object will contain position independent code, so all references
1039 from the dynamic object to this symbol will go through the global
1040 offset table. The dynamic linker will use the .dynsym entry to
1041 determine the address it must put in the global offset table, so
1042 both the dynamic object and the regular object will refer to the
1043 same memory location for the variable. */
1049 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1050 copy the initial value out of the dynamic object and into the
1051 runtime process image. We need to remember the offset into the
1052 .rel.bss section we are going to use. */
1053 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1057 srel
= htab
->srelbss
;
1060 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1061 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1064 /* We need to figure out the alignment required for this symbol. I
1065 have no idea how ELF linkers handle this. */
1066 power_of_two
= bfd_log2 (h
->size
);
1067 if (power_of_two
> 3)
1070 /* Apply the required alignment. */
1071 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1072 (bfd_size_type
) (1 << power_of_two
));
1073 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1075 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1079 /* Define the symbol as being at this point in the section. */
1080 h
->root
.u
.def
.section
= s
;
1081 h
->root
.u
.def
.value
= s
->_raw_size
;
1083 /* Increment the section size to make room for the symbol. */
1084 s
->_raw_size
+= h
->size
;
1089 /* This is the condition under which elf_i386_finish_dynamic_symbol
1090 will be called from elflink.h. If elflink.h doesn't call our
1091 finish_dynamic_symbol routine, we'll need to do something about
1092 initializing any .plt and .got entries in elf_i386_relocate_section. */
1093 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1095 && ((INFO)->shared \
1096 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1097 && ((H)->dynindx != -1 \
1098 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1100 /* Allocate space in .plt, .got and associated reloc sections for
1101 global syms. Also discards space allocated for relocs in the
1102 check_relocs function that we subsequently have found to be
1106 allocate_plt_and_got_and_discard_relocs (h
, inf
)
1107 struct elf_link_hash_entry
*h
;
1110 struct bfd_link_info
*info
;
1111 struct elf_i386_link_hash_table
*htab
;
1113 struct elf_i386_link_hash_entry
*eh
;
1115 if (h
->root
.type
== bfd_link_hash_indirect
1116 || h
->root
.type
== bfd_link_hash_warning
)
1119 info
= (struct bfd_link_info
*) inf
;
1120 htab
= elf_i386_hash_table (info
);
1122 if (htab
->root
.dynamic_sections_created
1123 && h
->plt
.refcount
> 0)
1125 /* Make sure this symbol is output as a dynamic symbol.
1126 Undefined weak syms won't yet be marked as dynamic. */
1127 if (h
->dynindx
== -1
1128 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1130 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1138 /* If this is the first .plt entry, make room for the special
1140 if (s
->_raw_size
== 0)
1141 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1143 h
->plt
.offset
= s
->_raw_size
;
1145 /* If this symbol is not defined in a regular file, and we are
1146 not generating a shared library, then set the symbol to this
1147 location in the .plt. This is required to make function
1148 pointers compare as equal between the normal executable and
1149 the shared library. */
1151 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1153 h
->root
.u
.def
.section
= s
;
1154 h
->root
.u
.def
.value
= h
->plt
.offset
;
1157 /* Make room for this entry. */
1158 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1160 /* We also need to make an entry in the .got.plt section, which
1161 will be placed in the .got section by the linker script. */
1167 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1169 /* We also need to make an entry in the .rel.plt section. */
1173 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1178 h
->plt
.offset
= (bfd_vma
) -1;
1179 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1182 if (h
->got
.refcount
> 0)
1186 /* Make sure this symbol is output as a dynamic symbol.
1187 Undefined weak syms won't yet be marked as dynamic. */
1188 if (h
->dynindx
== -1
1189 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1191 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1196 h
->got
.offset
= s
->_raw_size
;
1198 dyn
= htab
->root
.dynamic_sections_created
;
1199 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1200 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1203 h
->got
.offset
= (bfd_vma
) -1;
1205 /* In the shared -Bsymbolic case, discard space allocated for
1206 dynamic relocs against symbols which turn out to be defined
1207 in regular objects. For the normal shared case, discard space
1208 for relocs that have become local due to symbol visibility
1209 changes. For the non-shared case, discard space for symbols
1210 which turn out to need copy relocs or are not dynamic. */
1212 eh
= (struct elf_i386_link_hash_entry
*) h
;
1213 if (eh
->dyn_relocs
== NULL
)
1217 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1218 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1219 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1220 || (htab
->root
.dynamic_sections_created
1221 && (h
->root
.type
== bfd_link_hash_undefweak
1222 || h
->root
.type
== bfd_link_hash_undefined
))))
1224 /* Make sure this symbol is output as a dynamic symbol.
1225 Undefined weak syms won't yet be marked as dynamic. */
1226 if (h
->dynindx
== -1
1227 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1229 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1233 /* If that succeeded, we know we'll be keeping all the relocs. */
1234 if (h
->dynindx
!= -1)
1239 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1240 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1241 || info
->symbolic
)))
1243 struct elf_i386_dyn_relocs
*c
;
1245 for (c
= eh
->dyn_relocs
; c
!= NULL
; c
= c
->next
)
1246 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1252 /* Set the sizes of the dynamic sections. */
1255 elf_i386_size_dynamic_sections (output_bfd
, info
)
1256 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1257 struct bfd_link_info
*info
;
1259 struct elf_i386_link_hash_table
*htab
;
1265 htab
= elf_i386_hash_table (info
);
1266 dynobj
= htab
->root
.dynobj
;
1270 if (htab
->root
.dynamic_sections_created
)
1272 /* Set the contents of the .interp section to the interpreter. */
1275 s
= bfd_get_section_by_name (dynobj
, ".interp");
1278 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1279 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1283 /* Set up .got offsets for local syms. */
1284 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1286 bfd_signed_vma
*local_got
;
1287 bfd_signed_vma
*end_local_got
;
1288 bfd_size_type locsymcount
;
1289 Elf_Internal_Shdr
*symtab_hdr
;
1292 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1295 local_got
= elf_local_got_refcounts (i
);
1299 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1300 locsymcount
= symtab_hdr
->sh_info
;
1301 end_local_got
= local_got
+ locsymcount
;
1303 srel
= htab
->srelgot
;
1304 for (; local_got
< end_local_got
; ++local_got
)
1308 *local_got
= s
->_raw_size
;
1311 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1314 *local_got
= (bfd_vma
) -1;
1318 /* Allocate global sym .plt and .got entries. Also discard all
1320 elf_link_hash_traverse (&htab
->root
,
1321 allocate_plt_and_got_and_discard_relocs
,
1324 /* We now have determined the sizes of the various dynamic sections.
1325 Allocate memory for them. */
1327 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1329 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1334 || s
== htab
->sgotplt
)
1336 /* Strip this section if we don't need it; see the
1339 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1341 if (s
->_raw_size
== 0)
1343 /* If we don't need this section, strip it from the
1344 output file. This is mostly to handle .rel.bss and
1345 .rel.plt. We must create both sections in
1346 create_dynamic_sections, because they must be created
1347 before the linker maps input sections to output
1348 sections. The linker does that before
1349 adjust_dynamic_symbol is called, and it is that
1350 function which decides whether anything needs to go
1351 into these sections. */
1355 if (s
!= htab
->srelplt
)
1358 /* We use the reloc_count field as a counter if we need
1359 to copy relocs into the output file. */
1365 /* It's not one of our sections, so don't allocate space. */
1369 if (s
->_raw_size
== 0)
1371 _bfd_strip_section_from_output (info
, s
);
1375 /* Allocate memory for the section contents. We use bfd_zalloc
1376 here in case unused entries are not reclaimed before the
1377 section's contents are written out. This should not happen,
1378 but this way if it does, we get a R_386_NONE reloc instead
1380 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1381 if (s
->contents
== NULL
)
1385 if (htab
->root
.dynamic_sections_created
)
1387 /* Add some entries to the .dynamic section. We fill in the
1388 values later, in elf_i386_finish_dynamic_sections, but we
1389 must add the entries now so that we get the correct size for
1390 the .dynamic section. The DT_DEBUG entry is filled in by the
1391 dynamic linker and used by the debugger. */
1392 #define add_dynamic_entry(TAG, VAL) \
1393 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1397 if (!add_dynamic_entry (DT_DEBUG
, 0))
1401 if (htab
->splt
->_raw_size
!= 0)
1403 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1404 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1405 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1406 || !add_dynamic_entry (DT_JMPREL
, 0))
1412 if (!add_dynamic_entry (DT_REL
, 0)
1413 || !add_dynamic_entry (DT_RELSZ
, 0)
1414 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1418 if ((info
->flags
& DF_TEXTREL
) != 0)
1420 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1424 #undef add_dynamic_entry
1429 /* Relocate an i386 ELF section. */
1432 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1433 contents
, relocs
, local_syms
, local_sections
)
1435 struct bfd_link_info
*info
;
1437 asection
*input_section
;
1439 Elf_Internal_Rela
*relocs
;
1440 Elf_Internal_Sym
*local_syms
;
1441 asection
**local_sections
;
1443 struct elf_i386_link_hash_table
*htab
;
1445 Elf_Internal_Shdr
*symtab_hdr
;
1446 struct elf_link_hash_entry
**sym_hashes
;
1447 bfd_vma
*local_got_offsets
;
1449 Elf_Internal_Rela
*rel
;
1450 Elf_Internal_Rela
*relend
;
1452 htab
= elf_i386_hash_table (info
);
1453 dynobj
= htab
->root
.dynobj
;
1454 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1455 sym_hashes
= elf_sym_hashes (input_bfd
);
1456 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1460 relend
= relocs
+ input_section
->reloc_count
;
1461 for (; rel
< relend
; rel
++)
1464 reloc_howto_type
*howto
;
1465 unsigned long r_symndx
;
1466 struct elf_link_hash_entry
*h
;
1467 Elf_Internal_Sym
*sym
;
1471 boolean unresolved_reloc
;
1472 bfd_reloc_status_type r
;
1475 r_type
= ELF32_R_TYPE (rel
->r_info
);
1476 if (r_type
== (int) R_386_GNU_VTINHERIT
1477 || r_type
== (int) R_386_GNU_VTENTRY
)
1480 if ((indx
= (unsigned) r_type
) >= R_386_standard
1481 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1482 >= R_386_ext
- R_386_standard
))
1484 bfd_set_error (bfd_error_bad_value
);
1487 howto
= elf_howto_table
+ indx
;
1489 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1491 if (info
->relocateable
)
1493 /* This is a relocateable link. We don't have to change
1494 anything, unless the reloc is against a section symbol,
1495 in which case we have to adjust according to where the
1496 section symbol winds up in the output section. */
1497 if (r_symndx
< symtab_hdr
->sh_info
)
1499 sym
= local_syms
+ r_symndx
;
1500 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1504 sec
= local_sections
[r_symndx
];
1505 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1506 val
+= sec
->output_offset
+ sym
->st_value
;
1507 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1514 /* This is a final link. */
1518 unresolved_reloc
= false;
1519 if (r_symndx
< symtab_hdr
->sh_info
)
1521 sym
= local_syms
+ r_symndx
;
1522 sec
= local_sections
[r_symndx
];
1523 relocation
= (sec
->output_section
->vma
1524 + sec
->output_offset
1529 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1530 while (h
->root
.type
== bfd_link_hash_indirect
1531 || h
->root
.type
== bfd_link_hash_warning
)
1532 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1535 if (h
->root
.type
== bfd_link_hash_defined
1536 || h
->root
.type
== bfd_link_hash_defweak
)
1538 sec
= h
->root
.u
.def
.section
;
1539 if (sec
->output_section
== NULL
)
1540 /* Set a flag that will be cleared later if we find a
1541 relocation value for this symbol. output_section
1542 is typically NULL for symbols satisfied by a shared
1544 unresolved_reloc
= true;
1546 relocation
= (h
->root
.u
.def
.value
1547 + sec
->output_section
->vma
1548 + sec
->output_offset
);
1550 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1552 else if (info
->shared
1553 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1554 && !info
->no_undefined
1555 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1559 if (! ((*info
->callbacks
->undefined_symbol
)
1560 (info
, h
->root
.root
.string
, input_bfd
,
1561 input_section
, rel
->r_offset
,
1562 (!info
->shared
|| info
->no_undefined
1563 || ELF_ST_VISIBILITY (h
->other
)))))
1571 /* Relocation is to the entry for this symbol in the global
1573 if (htab
->sgot
== NULL
)
1580 off
= h
->got
.offset
;
1581 dyn
= htab
->root
.dynamic_sections_created
;
1582 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1586 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1587 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1589 /* This is actually a static link, or it is a
1590 -Bsymbolic link and the symbol is defined
1591 locally, or the symbol was forced to be local
1592 because of a version file. We must initialize
1593 this entry in the global offset table. Since the
1594 offset must always be a multiple of 4, we use the
1595 least significant bit to record whether we have
1596 initialized it already.
1598 When doing a dynamic link, we create a .rel.got
1599 relocation entry to initialize the value. This
1600 is done in the finish_dynamic_symbol routine. */
1605 bfd_put_32 (output_bfd
, relocation
,
1606 htab
->sgot
->contents
+ off
);
1611 unresolved_reloc
= false;
1615 if (local_got_offsets
== NULL
)
1618 off
= local_got_offsets
[r_symndx
];
1620 /* The offset must always be a multiple of 4. We use
1621 the least significant bit to record whether we have
1622 already generated the necessary reloc. */
1627 bfd_put_32 (output_bfd
, relocation
,
1628 htab
->sgot
->contents
+ off
);
1633 Elf_Internal_Rel outrel
;
1635 srelgot
= htab
->srelgot
;
1636 if (srelgot
== NULL
)
1639 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1640 + htab
->sgot
->output_offset
1642 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1643 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1644 (((Elf32_External_Rel
*)
1646 + srelgot
->reloc_count
));
1647 ++srelgot
->reloc_count
;
1650 local_got_offsets
[r_symndx
] |= 1;
1654 if (off
>= (bfd_vma
) -2)
1657 relocation
= htab
->sgot
->output_offset
+ off
;
1661 /* Relocation is relative to the start of the global offset
1664 /* Note that sgot->output_offset is not involved in this
1665 calculation. We always want the start of .got. If we
1666 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1667 permitted by the ABI, we might have to change this
1669 relocation
-= htab
->sgot
->output_section
->vma
;
1673 /* Use global offset table as symbol value. */
1674 relocation
= htab
->sgot
->output_section
->vma
;
1675 unresolved_reloc
= false;
1679 /* Relocation is to the entry for this symbol in the
1680 procedure linkage table. */
1682 /* Resolve a PLT32 reloc against a local symbol directly,
1683 without using the procedure linkage table. */
1687 if (h
->plt
.offset
== (bfd_vma
) -1
1688 || htab
->splt
== NULL
)
1690 /* We didn't make a PLT entry for this symbol. This
1691 happens when statically linking PIC code, or when
1692 using -Bsymbolic. */
1696 relocation
= (htab
->splt
->output_section
->vma
1697 + htab
->splt
->output_offset
1699 unresolved_reloc
= false;
1705 && (input_section
->flags
& SEC_ALLOC
) != 0
1706 && (r_type
!= R_386_PC32
1709 && (! info
->symbolic
1710 || (h
->elf_link_hash_flags
1711 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1713 && (input_section
->flags
& SEC_ALLOC
) != 0
1716 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1717 && (((h
->elf_link_hash_flags
1718 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1719 && (h
->elf_link_hash_flags
1720 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1721 || h
->root
.type
== bfd_link_hash_undefweak
1722 || h
->root
.type
== bfd_link_hash_undefined
)))
1724 Elf_Internal_Rel outrel
;
1725 boolean skip
, relocate
;
1727 /* When generating a shared object, these relocations
1728 are copied into the output file to be resolved at run
1735 name
= (bfd_elf_string_from_elf_section
1737 elf_elfheader (input_bfd
)->e_shstrndx
,
1738 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1742 if (strncmp (name
, ".rel", 4) != 0
1743 || strcmp (bfd_get_section_name (input_bfd
,
1747 if (input_bfd
->my_archive
)
1748 (*_bfd_error_handler
)\
1749 (_("%s(%s): bad relocation section name `%s\'"),
1750 bfd_get_filename (input_bfd
->my_archive
),
1751 bfd_get_filename (input_bfd
),
1754 (*_bfd_error_handler
)
1755 (_("%s: bad relocation section name `%s\'"),
1756 bfd_get_filename (input_bfd
),
1761 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1768 if (elf_section_data (input_section
)->stab_info
== NULL
)
1769 outrel
.r_offset
= rel
->r_offset
;
1772 off
= (_bfd_stab_section_offset
1773 (output_bfd
, htab
->root
.stab_info
, input_section
,
1774 &elf_section_data (input_section
)->stab_info
,
1776 if (off
== (bfd_vma
) -1)
1778 outrel
.r_offset
= off
;
1781 outrel
.r_offset
+= (input_section
->output_section
->vma
1782 + input_section
->output_offset
);
1786 memset (&outrel
, 0, sizeof outrel
);
1791 && (r_type
== R_386_PC32
1794 || (h
->elf_link_hash_flags
1795 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1799 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1803 /* This symbol is local, or marked to become local. */
1805 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1808 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1809 (((Elf32_External_Rel
*)
1811 + sreloc
->reloc_count
));
1812 ++sreloc
->reloc_count
;
1814 /* If this reloc is against an external symbol, we do
1815 not want to fiddle with the addend. Otherwise, we
1816 need to include the symbol value so that it becomes
1817 an addend for the dynamic reloc. */
1828 /* FIXME: Why do we allow debugging sections to escape this error?
1829 More importantly, why do we not emit dynamic relocs for
1830 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1831 If we had emitted the dynamic reloc, we could remove the
1833 if (unresolved_reloc
1835 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1836 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1837 (*_bfd_error_handler
)
1838 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1839 bfd_get_filename (input_bfd
),
1840 bfd_get_section_name (input_bfd
, input_section
),
1841 (long) rel
->r_offset
,
1842 h
->root
.root
.string
);
1844 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1845 contents
, rel
->r_offset
,
1846 relocation
, (bfd_vma
) 0);
1853 case bfd_reloc_overflow
:
1858 name
= h
->root
.root
.string
;
1861 name
= bfd_elf_string_from_elf_section (input_bfd
,
1862 symtab_hdr
->sh_link
,
1867 name
= bfd_section_name (input_bfd
, sec
);
1869 if (! ((*info
->callbacks
->reloc_overflow
)
1870 (info
, name
, howto
->name
, (bfd_vma
) 0,
1871 input_bfd
, input_section
, rel
->r_offset
)))
1877 case bfd_reloc_outofrange
:
1886 /* Finish up dynamic symbol handling. We set the contents of various
1887 dynamic sections here. */
1890 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1892 struct bfd_link_info
*info
;
1893 struct elf_link_hash_entry
*h
;
1894 Elf_Internal_Sym
*sym
;
1896 struct elf_i386_link_hash_table
*htab
;
1899 htab
= elf_i386_hash_table (info
);
1900 dynobj
= htab
->root
.dynobj
;
1902 if (h
->plt
.offset
!= (bfd_vma
) -1)
1906 Elf_Internal_Rel rel
;
1908 /* This symbol has an entry in the procedure linkage table. Set
1911 if (h
->dynindx
== -1
1912 || htab
->splt
== NULL
1913 || htab
->sgotplt
== NULL
1914 || htab
->srelplt
== NULL
)
1917 /* Get the index in the procedure linkage table which
1918 corresponds to this symbol. This is the index of this symbol
1919 in all the symbols for which we are making plt entries. The
1920 first entry in the procedure linkage table is reserved. */
1921 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1923 /* Get the offset into the .got table of the entry that
1924 corresponds to this function. Each .got entry is 4 bytes.
1925 The first three are reserved. */
1926 got_offset
= (plt_index
+ 3) * 4;
1928 /* Fill in the entry in the procedure linkage table. */
1931 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1933 bfd_put_32 (output_bfd
,
1934 (htab
->sgotplt
->output_section
->vma
1935 + htab
->sgotplt
->output_offset
1937 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1941 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1943 bfd_put_32 (output_bfd
, got_offset
,
1944 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1947 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1948 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1949 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1950 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1952 /* Fill in the entry in the global offset table. */
1953 bfd_put_32 (output_bfd
,
1954 (htab
->splt
->output_section
->vma
1955 + htab
->splt
->output_offset
1958 htab
->sgotplt
->contents
+ got_offset
);
1960 /* Fill in the entry in the .rel.plt section. */
1961 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1962 + htab
->sgotplt
->output_offset
1964 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1965 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1966 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1969 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1971 /* Mark the symbol as undefined, rather than as defined in
1972 the .plt section. Leave the value alone. */
1973 sym
->st_shndx
= SHN_UNDEF
;
1977 if (h
->got
.offset
!= (bfd_vma
) -1)
1979 Elf_Internal_Rel rel
;
1981 /* This symbol has an entry in the global offset table. Set it
1984 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
1987 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1988 + htab
->sgot
->output_offset
1989 + (h
->got
.offset
& ~(bfd_vma
) 1));
1991 /* If this is a static link, or it is a -Bsymbolic link and the
1992 symbol is defined locally or was forced to be local because
1993 of a version file, we just want to emit a RELATIVE reloc.
1994 The entry in the global offset table will already have been
1995 initialized in the relocate_section function. */
1999 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2000 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2002 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2003 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2007 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2008 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2009 htab
->sgot
->contents
+ h
->got
.offset
);
2010 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2013 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2014 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2015 + htab
->srelgot
->reloc_count
));
2016 ++htab
->srelgot
->reloc_count
;
2019 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2021 Elf_Internal_Rel rel
;
2023 /* This symbol needs a copy reloc. Set it up. */
2025 if (h
->dynindx
== -1
2026 || (h
->root
.type
!= bfd_link_hash_defined
2027 && h
->root
.type
!= bfd_link_hash_defweak
)
2028 || htab
->srelbss
== NULL
)
2031 rel
.r_offset
= (h
->root
.u
.def
.value
2032 + h
->root
.u
.def
.section
->output_section
->vma
2033 + h
->root
.u
.def
.section
->output_offset
);
2034 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2035 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2036 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2037 + htab
->srelbss
->reloc_count
));
2038 ++htab
->srelbss
->reloc_count
;
2041 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2042 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2043 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2044 sym
->st_shndx
= SHN_ABS
;
2049 /* Finish up the dynamic sections. */
2052 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2054 struct bfd_link_info
*info
;
2056 struct elf_i386_link_hash_table
*htab
;
2060 htab
= elf_i386_hash_table (info
);
2061 dynobj
= htab
->root
.dynobj
;
2062 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2064 if (htab
->root
.dynamic_sections_created
)
2066 Elf32_External_Dyn
*dyncon
, *dynconend
;
2068 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2071 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2072 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2073 for (; dyncon
< dynconend
; dyncon
++)
2075 Elf_Internal_Dyn dyn
;
2077 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2085 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2086 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2090 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2091 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
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
;
2099 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2103 /* My reading of the SVR4 ABI indicates that the
2104 procedure linkage table relocs (DT_JMPREL) should be
2105 included in the overall relocs (DT_REL). This is
2106 what Solaris does. However, UnixWare can not handle
2107 that case. Therefore, we override the DT_RELSZ entry
2108 here to make it not include the JMPREL relocs. Since
2109 the linker script arranges for .rel.plt to follow all
2110 other relocation sections, we don't have to worry
2111 about changing the DT_REL entry. */
2112 if (htab
->srelplt
!= NULL
)
2114 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2115 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2117 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2119 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2124 /* Fill in the first entry in the procedure linkage table. */
2125 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2128 memcpy (htab
->splt
->contents
,
2129 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2132 memcpy (htab
->splt
->contents
,
2133 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2134 bfd_put_32 (output_bfd
,
2135 (htab
->sgotplt
->output_section
->vma
2136 + htab
->sgotplt
->output_offset
2138 htab
->splt
->contents
+ 2);
2139 bfd_put_32 (output_bfd
,
2140 (htab
->sgotplt
->output_section
->vma
2141 + htab
->sgotplt
->output_offset
2143 htab
->splt
->contents
+ 8);
2146 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2147 really seem like the right value. */
2148 elf_section_data (htab
->splt
->output_section
)
2149 ->this_hdr
.sh_entsize
= 4;
2155 /* Fill in the first three entries in the global offset table. */
2156 if (htab
->sgotplt
->_raw_size
> 0)
2158 bfd_put_32 (output_bfd
,
2159 (sdyn
== NULL
? (bfd_vma
) 0
2160 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2161 htab
->sgotplt
->contents
);
2162 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2163 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2166 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2171 /* Set the correct type for an x86 ELF section. We do this by the
2172 section name, which is a hack, but ought to work. */
2175 elf_i386_fake_sections (abfd
, hdr
, sec
)
2176 bfd
*abfd ATTRIBUTE_UNUSED
;
2177 Elf32_Internal_Shdr
*hdr
;
2180 register const char *name
;
2182 name
= bfd_get_section_name (abfd
, sec
);
2184 if (strcmp (name
, ".reloc") == 0)
2186 * This is an ugly, but unfortunately necessary hack that is
2187 * needed when producing EFI binaries on x86. It tells
2188 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2189 * containing ELF relocation info. We need this hack in order to
2190 * be able to generate ELF binaries that can be translated into
2191 * EFI applications (which are essentially COFF objects). Those
2192 * files contain a COFF ".reloc" section inside an ELFNN object,
2193 * which would normally cause BFD to segfault because it would
2194 * attempt to interpret this section as containing relocation
2195 * entries for section "oc". With this hack enabled, ".reloc"
2196 * will be treated as a normal data section, which will avoid the
2197 * segfault. However, you won't be able to create an ELFNN binary
2198 * with a section named "oc" that needs relocations, but that's
2199 * the kind of ugly side-effects you get when detecting section
2200 * types based on their names... In practice, this limitation is
2203 hdr
->sh_type
= SHT_PROGBITS
;
2208 static enum elf_reloc_type_class
2209 elf_i386_reloc_type_class (type
)
2214 case R_386_RELATIVE
:
2215 return reloc_class_relative
;
2216 case R_386_JUMP_SLOT
:
2217 return reloc_class_plt
;
2219 return reloc_class_copy
;
2221 return reloc_class_normal
;
2225 /* Support for core dump NOTE sections */
2227 elf_i386_grok_prstatus (abfd
, note
)
2229 Elf_Internal_Note
*note
;
2234 switch (note
->descsz
)
2239 case 144: /* Linux/i386 */
2241 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2244 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2253 /* Make a ".reg/999" section. */
2254 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2255 raw_size
, note
->descpos
+ offset
);
2259 elf_i386_grok_psinfo (abfd
, note
)
2261 Elf_Internal_Note
*note
;
2263 switch (note
->descsz
)
2268 case 128: /* Linux/MIPS elf_prpsinfo */
2269 elf_tdata (abfd
)->core_program
2270 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
2271 elf_tdata (abfd
)->core_command
2272 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
2275 /* Note that for some reason, a spurious space is tacked
2276 onto the end of the args in some (at least one anyway)
2277 implementations, so strip it off if it exists. */
2280 char *command
= elf_tdata (abfd
)->core_command
;
2281 int n
= strlen (command
);
2283 if (0 < n
&& command
[n
- 1] == ' ')
2284 command
[n
- 1] = '\0';
2290 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2291 #define TARGET_LITTLE_NAME "elf32-i386"
2292 #define ELF_ARCH bfd_arch_i386
2293 #define ELF_MACHINE_CODE EM_386
2294 #define ELF_MAXPAGESIZE 0x1000
2296 #define elf_backend_can_gc_sections 1
2297 #define elf_backend_want_got_plt 1
2298 #define elf_backend_plt_readonly 1
2299 #define elf_backend_want_plt_sym 0
2300 #define elf_backend_got_header_size 12
2301 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2303 #define elf_info_to_howto elf_i386_info_to_howto
2304 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2306 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2307 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2308 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2310 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2311 #define elf_backend_check_relocs elf_i386_check_relocs
2312 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2313 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2314 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2315 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2316 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2317 #define elf_backend_relocate_section elf_i386_relocate_section
2318 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2319 #define elf_backend_fake_sections elf_i386_fake_sections
2320 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2321 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2322 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2324 #include "elf32-target.h"