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
34 PARAMS ((bfd
*, const char *));
35 static boolean elf_i386_grok_prstatus
36 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
37 static boolean elf_i386_grok_psinfo
38 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
39 static struct bfd_hash_entry
*link_hash_newfunc
40 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
41 static struct bfd_link_hash_table
*elf_i386_link_hash_table_create
43 static boolean create_got_section
44 PARAMS((bfd
*, struct bfd_link_info
*));
45 static boolean elf_i386_create_dynamic_sections
46 PARAMS((bfd
*, struct bfd_link_info
*));
47 static void elf_i386_copy_indirect_symbol
48 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
49 static boolean elf_i386_check_relocs
50 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
51 const Elf_Internal_Rela
*));
52 static asection
*elf_i386_gc_mark_hook
53 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
54 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
55 static boolean elf_i386_gc_sweep_hook
56 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
57 const Elf_Internal_Rela
*));
58 static boolean elf_i386_adjust_dynamic_symbol
59 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
60 static boolean allocate_dynrelocs
61 PARAMS ((struct elf_link_hash_entry
*, PTR
));
62 static boolean readonly_dynrelocs
63 PARAMS ((struct elf_link_hash_entry
*, PTR
));
64 static boolean elf_i386_fake_sections
65 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, asection
*));
66 static boolean elf_i386_size_dynamic_sections
67 PARAMS ((bfd
*, struct bfd_link_info
*));
68 static boolean elf_i386_relocate_section
69 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
70 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
71 static boolean elf_i386_finish_dynamic_symbol
72 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
74 static enum elf_reloc_type_class elf_i386_reloc_type_class
75 PARAMS ((const Elf_Internal_Rela
*));
76 static boolean elf_i386_finish_dynamic_sections
77 PARAMS ((bfd
*, struct bfd_link_info
*));
79 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
83 static reloc_howto_type elf_howto_table
[]=
85 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_386_NONE",
87 true, 0x00000000, 0x00000000, false),
88 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_386_32",
90 true, 0xffffffff, 0xffffffff, false),
91 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_386_PC32",
93 true, 0xffffffff, 0xffffffff, true),
94 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_386_GOT32",
96 true, 0xffffffff, 0xffffffff, false),
97 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_386_PLT32",
99 true, 0xffffffff, 0xffffffff, true),
100 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
101 bfd_elf_generic_reloc
, "R_386_COPY",
102 true, 0xffffffff, 0xffffffff, false),
103 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
104 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
105 true, 0xffffffff, 0xffffffff, false),
106 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
107 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
108 true, 0xffffffff, 0xffffffff, false),
109 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_386_RELATIVE",
111 true, 0xffffffff, 0xffffffff, false),
112 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
113 bfd_elf_generic_reloc
, "R_386_GOTOFF",
114 true, 0xffffffff, 0xffffffff, false),
115 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
116 bfd_elf_generic_reloc
, "R_386_GOTPC",
117 true, 0xffffffff, 0xffffffff, true),
119 /* We have a gap in the reloc numbers here.
120 R_386_standard counts the number up to this point, and
121 R_386_ext_offset is the value to subtract from a reloc type of
122 R_386_16 thru R_386_PC8 to form an index into this table. */
123 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
124 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
126 /* The remaining relocs are a GNU extension. */
127 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
128 bfd_elf_generic_reloc
, "R_386_16",
129 true, 0xffff, 0xffff, false),
130 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
131 bfd_elf_generic_reloc
, "R_386_PC16",
132 true, 0xffff, 0xffff, true),
133 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
134 bfd_elf_generic_reloc
, "R_386_8",
135 true, 0xff, 0xff, false),
136 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
137 bfd_elf_generic_reloc
, "R_386_PC8",
138 true, 0xff, 0xff, true),
141 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
142 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
144 /* GNU extension to record C++ vtable hierarchy. */
145 HOWTO (R_386_GNU_VTINHERIT
, /* type */
147 2, /* size (0 = byte, 1 = short, 2 = long) */
149 false, /* pc_relative */
151 complain_overflow_dont
, /* complain_on_overflow */
152 NULL
, /* special_function */
153 "R_386_GNU_VTINHERIT", /* name */
154 false, /* partial_inplace */
159 /* GNU extension to record C++ vtable member usage. */
160 HOWTO (R_386_GNU_VTENTRY
, /* type */
162 2, /* size (0 = byte, 1 = short, 2 = long) */
164 false, /* pc_relative */
166 complain_overflow_dont
, /* complain_on_overflow */
167 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
168 "R_386_GNU_VTENTRY", /* name */
169 false, /* partial_inplace */
174 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
178 #ifdef DEBUG_GEN_RELOC
179 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
184 static reloc_howto_type
*
185 elf_i386_reloc_type_lookup (abfd
, code
)
186 bfd
*abfd ATTRIBUTE_UNUSED
;
187 bfd_reloc_code_real_type code
;
192 TRACE ("BFD_RELOC_NONE");
193 return &elf_howto_table
[(unsigned int) R_386_NONE
];
196 TRACE ("BFD_RELOC_32");
197 return &elf_howto_table
[(unsigned int) R_386_32
];
200 TRACE ("BFD_RELOC_CTOR");
201 return &elf_howto_table
[(unsigned int) R_386_32
];
203 case BFD_RELOC_32_PCREL
:
204 TRACE ("BFD_RELOC_PC32");
205 return &elf_howto_table
[(unsigned int) R_386_PC32
];
207 case BFD_RELOC_386_GOT32
:
208 TRACE ("BFD_RELOC_386_GOT32");
209 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
211 case BFD_RELOC_386_PLT32
:
212 TRACE ("BFD_RELOC_386_PLT32");
213 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
215 case BFD_RELOC_386_COPY
:
216 TRACE ("BFD_RELOC_386_COPY");
217 return &elf_howto_table
[(unsigned int) R_386_COPY
];
219 case BFD_RELOC_386_GLOB_DAT
:
220 TRACE ("BFD_RELOC_386_GLOB_DAT");
221 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
223 case BFD_RELOC_386_JUMP_SLOT
:
224 TRACE ("BFD_RELOC_386_JUMP_SLOT");
225 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
227 case BFD_RELOC_386_RELATIVE
:
228 TRACE ("BFD_RELOC_386_RELATIVE");
229 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
231 case BFD_RELOC_386_GOTOFF
:
232 TRACE ("BFD_RELOC_386_GOTOFF");
233 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
235 case BFD_RELOC_386_GOTPC
:
236 TRACE ("BFD_RELOC_386_GOTPC");
237 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
239 /* The remaining relocs are a GNU extension. */
241 TRACE ("BFD_RELOC_16");
242 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
244 case BFD_RELOC_16_PCREL
:
245 TRACE ("BFD_RELOC_16_PCREL");
246 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
249 TRACE ("BFD_RELOC_8");
250 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
252 case BFD_RELOC_8_PCREL
:
253 TRACE ("BFD_RELOC_8_PCREL");
254 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
256 case BFD_RELOC_VTABLE_INHERIT
:
257 TRACE ("BFD_RELOC_VTABLE_INHERIT");
258 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
261 case BFD_RELOC_VTABLE_ENTRY
:
262 TRACE ("BFD_RELOC_VTABLE_ENTRY");
263 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
275 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
276 bfd
*abfd ATTRIBUTE_UNUSED
;
277 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
278 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
284 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
285 bfd
*abfd ATTRIBUTE_UNUSED
;
287 Elf32_Internal_Rel
*dst
;
289 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
292 if ((indx
= r_type
) >= R_386_standard
293 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
294 >= R_386_ext
- R_386_standard
)
295 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
296 >= R_386_vt
- R_386_ext
))
298 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
299 bfd_archive_filename (abfd
), (int) r_type
);
300 indx
= (unsigned int) R_386_NONE
;
302 cache_ptr
->howto
= &elf_howto_table
[indx
];
305 /* Return whether a symbol name implies a local label. The UnixWare
306 2.1 cc generates temporary symbols that start with .X, so we
307 recognize them here. FIXME: do other SVR4 compilers also use .X?.
308 If so, we should move the .X recognition into
309 _bfd_elf_is_local_label_name. */
312 elf_i386_is_local_label_name (abfd
, name
)
316 if (name
[0] == '.' && name
[1] == 'X')
319 return _bfd_elf_is_local_label_name (abfd
, name
);
322 /* Support for core dump NOTE sections. */
324 elf_i386_grok_prstatus (abfd
, note
)
326 Elf_Internal_Note
*note
;
331 switch (note
->descsz
)
336 case 144: /* Linux/i386 */
338 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
341 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
350 /* Make a ".reg/999" section. */
351 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
352 raw_size
, note
->descpos
+ offset
);
356 elf_i386_grok_psinfo (abfd
, note
)
358 Elf_Internal_Note
*note
;
360 switch (note
->descsz
)
365 case 128: /* Linux/MIPS elf_prpsinfo */
366 elf_tdata (abfd
)->core_program
367 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
368 elf_tdata (abfd
)->core_command
369 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
372 /* Note that for some reason, a spurious space is tacked
373 onto the end of the args in some (at least one anyway)
374 implementations, so strip it off if it exists. */
377 char *command
= elf_tdata (abfd
)->core_command
;
378 int n
= strlen (command
);
380 if (0 < n
&& command
[n
- 1] == ' ')
381 command
[n
- 1] = '\0';
387 /* Functions for the i386 ELF linker.
389 In order to gain some understanding of code in this file without
390 knowing all the intricate details of the linker, note the
393 Functions named elf_i386_* are called by external routines, other
394 functions are only called locally. elf_i386_* functions appear
395 in this file more or less in the order in which they are called
396 from external routines. eg. elf_i386_check_relocs is called
397 early in the link process, elf_i386_finish_dynamic_sections is
398 one of the last functions. */
401 /* The name of the dynamic interpreter. This is put in the .interp
404 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
406 /* The size in bytes of an entry in the procedure linkage table. */
408 #define PLT_ENTRY_SIZE 16
410 /* The first entry in an absolute procedure linkage table looks like
411 this. See the SVR4 ABI i386 supplement to see how this works. */
413 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
415 0xff, 0x35, /* pushl contents of address */
416 0, 0, 0, 0, /* replaced with address of .got + 4. */
417 0xff, 0x25, /* jmp indirect */
418 0, 0, 0, 0, /* replaced with address of .got + 8. */
419 0, 0, 0, 0 /* pad out to 16 bytes. */
422 /* Subsequent entries in an absolute procedure linkage table look like
425 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
427 0xff, 0x25, /* jmp indirect */
428 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
429 0x68, /* pushl immediate */
430 0, 0, 0, 0, /* replaced with offset into relocation table. */
431 0xe9, /* jmp relative */
432 0, 0, 0, 0 /* replaced with offset to start of .plt. */
435 /* The first entry in a PIC procedure linkage table look like this. */
437 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
439 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
440 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
441 0, 0, 0, 0 /* pad out to 16 bytes. */
444 /* Subsequent entries in a PIC procedure linkage table look like this. */
446 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
448 0xff, 0xa3, /* jmp *offset(%ebx) */
449 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
450 0x68, /* pushl immediate */
451 0, 0, 0, 0, /* replaced with offset into relocation table. */
452 0xe9, /* jmp relative */
453 0, 0, 0, 0 /* replaced with offset to start of .plt. */
456 /* The i386 linker needs to keep track of the number of relocs that it
457 decides to copy as dynamic relocs in check_relocs for each symbol.
458 This is so that it can later discard them if they are found to be
459 unnecessary. We store the information in a field extending the
460 regular ELF linker hash table. */
462 struct elf_i386_dyn_relocs
464 struct elf_i386_dyn_relocs
*next
;
466 /* The input section of the reloc. */
469 /* Total number of relocs copied for the input section. */
472 /* Number of pc-relative relocs copied for the input section. */
473 bfd_size_type pc_count
;
476 /* i386 ELF linker hash entry. */
478 struct elf_i386_link_hash_entry
480 struct elf_link_hash_entry elf
;
482 /* Track dynamic relocs copied for this symbol. */
483 struct elf_i386_dyn_relocs
*dyn_relocs
;
486 /* i386 ELF linker hash table. */
488 struct elf_i386_link_hash_table
490 struct elf_link_hash_table elf
;
492 /* Short-cuts to get to dynamic linker sections. */
502 /* Get the i386 ELF linker hash table from a link_info structure. */
504 #define elf_i386_hash_table(p) \
505 ((struct elf_i386_link_hash_table *) ((p)->hash))
507 /* Create an entry in an i386 ELF linker hash table. */
509 static struct bfd_hash_entry
*
510 link_hash_newfunc (entry
, table
, string
)
511 struct bfd_hash_entry
*entry
;
512 struct bfd_hash_table
*table
;
515 /* Allocate the structure if it has not already been allocated by a
519 entry
= bfd_hash_allocate (table
,
520 sizeof (struct elf_i386_link_hash_entry
));
525 /* Call the allocation method of the superclass. */
526 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
529 struct elf_i386_link_hash_entry
*eh
;
531 eh
= (struct elf_i386_link_hash_entry
*) entry
;
532 eh
->dyn_relocs
= NULL
;
538 /* Create an i386 ELF linker hash table. */
540 static struct bfd_link_hash_table
*
541 elf_i386_link_hash_table_create (abfd
)
544 struct elf_i386_link_hash_table
*ret
;
545 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
547 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
551 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
553 bfd_release (abfd
, ret
);
565 return &ret
->elf
.root
;
568 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
569 shortcuts to them in our hash table. */
572 create_got_section (dynobj
, info
)
574 struct bfd_link_info
*info
;
576 struct elf_i386_link_hash_table
*htab
;
578 if (! _bfd_elf_create_got_section (dynobj
, info
))
581 htab
= elf_i386_hash_table (info
);
582 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
583 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
584 if (!htab
->sgot
|| !htab
->sgotplt
)
587 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
588 if (htab
->srelgot
== NULL
589 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
590 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
591 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
593 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
598 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
599 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
603 elf_i386_create_dynamic_sections (dynobj
, info
)
605 struct bfd_link_info
*info
;
607 struct elf_i386_link_hash_table
*htab
;
609 htab
= elf_i386_hash_table (info
);
610 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
613 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
616 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
617 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
618 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
620 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
622 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
623 || (!info
->shared
&& !htab
->srelbss
))
629 /* Copy the extra info we tack onto an elf_link_hash_entry. */
632 elf_i386_copy_indirect_symbol (dir
, ind
)
633 struct elf_link_hash_entry
*dir
, *ind
;
635 struct elf_i386_link_hash_entry
*edir
, *eind
;
637 edir
= (struct elf_i386_link_hash_entry
*) dir
;
638 eind
= (struct elf_i386_link_hash_entry
*) ind
;
640 if (edir
->dyn_relocs
== NULL
)
642 edir
->dyn_relocs
= eind
->dyn_relocs
;
643 eind
->dyn_relocs
= NULL
;
645 else if (eind
->dyn_relocs
!= NULL
)
648 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
651 /* Look through the relocs for a section during the first phase, and
652 calculate needed space in the global offset table, procedure linkage
653 table, and dynamic reloc sections. */
656 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
658 struct bfd_link_info
*info
;
660 const Elf_Internal_Rela
*relocs
;
662 struct elf_i386_link_hash_table
*htab
;
663 Elf_Internal_Shdr
*symtab_hdr
;
664 struct elf_link_hash_entry
**sym_hashes
;
665 const Elf_Internal_Rela
*rel
;
666 const Elf_Internal_Rela
*rel_end
;
669 if (info
->relocateable
)
672 htab
= elf_i386_hash_table (info
);
673 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
674 sym_hashes
= elf_sym_hashes (abfd
);
678 rel_end
= relocs
+ sec
->reloc_count
;
679 for (rel
= relocs
; rel
< rel_end
; rel
++)
681 unsigned long r_symndx
;
682 struct elf_link_hash_entry
*h
;
684 r_symndx
= ELF32_R_SYM (rel
->r_info
);
686 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
688 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
689 bfd_archive_filename (abfd
),
694 if (r_symndx
< symtab_hdr
->sh_info
)
697 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
699 switch (ELF32_R_TYPE (rel
->r_info
))
702 /* This symbol requires a global offset table entry. */
705 h
->got
.refcount
+= 1;
709 bfd_signed_vma
*local_got_refcounts
;
711 /* This is a global offset table entry for a local symbol. */
712 local_got_refcounts
= elf_local_got_refcounts (abfd
);
713 if (local_got_refcounts
== NULL
)
717 size
= symtab_hdr
->sh_info
;
718 size
*= sizeof (bfd_signed_vma
);
719 local_got_refcounts
= ((bfd_signed_vma
*)
720 bfd_zalloc (abfd
, size
));
721 if (local_got_refcounts
== NULL
)
723 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
725 local_got_refcounts
[r_symndx
] += 1;
731 if (htab
->sgot
== NULL
)
733 if (htab
->elf
.dynobj
== NULL
)
734 htab
->elf
.dynobj
= abfd
;
735 if (!create_got_section (htab
->elf
.dynobj
, info
))
741 /* This symbol requires a procedure linkage table entry. We
742 actually build the entry in adjust_dynamic_symbol,
743 because this might be a case of linking PIC code which is
744 never referenced by a dynamic object, in which case we
745 don't need to generate a procedure linkage table entry
748 /* If this is a local symbol, we resolve it directly without
749 creating a procedure linkage table entry. */
753 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
754 h
->plt
.refcount
+= 1;
759 if (h
!= NULL
&& !info
->shared
)
761 /* If this reloc is in a read-only section, we might
762 need a copy reloc. We can't check reliably at this
763 stage whether the section is read-only, as input
764 sections have not yet been mapped to output sections.
765 Tentatively set the flag for now, and correct in
766 adjust_dynamic_symbol. */
767 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
769 /* We may need a .plt entry if the function this reloc
770 refers to is in a shared lib. */
771 h
->plt
.refcount
+= 1;
774 /* If we are creating a shared library, and this is a reloc
775 against a global symbol, or a non PC relative reloc
776 against a local symbol, then we need to copy the reloc
777 into the shared library. However, if we are linking with
778 -Bsymbolic, we do not need to copy a reloc against a
779 global symbol which is defined in an object we are
780 including in the link (i.e., DEF_REGULAR is set). At
781 this point we have not seen all the input files, so it is
782 possible that DEF_REGULAR is not set now but will be set
783 later (it is never cleared). In case of a weak definition,
784 DEF_REGULAR may be cleared later by a strong definition in
785 a shared library. We account for that possibility below by
786 storing information in the relocs_copied field of the hash
787 table entry. A similar situation occurs when creating
788 shared libraries and symbol visibility changes render the
791 If on the other hand, we are creating an executable, we
792 may need to keep relocations for symbols satisfied by a
793 dynamic library if we manage to avoid copy relocs for the
796 && (sec
->flags
& SEC_ALLOC
) != 0
797 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
800 || h
->root
.type
== bfd_link_hash_defweak
801 || (h
->elf_link_hash_flags
802 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
804 && (sec
->flags
& SEC_ALLOC
) != 0
806 && (h
->root
.type
== bfd_link_hash_defweak
807 || (h
->elf_link_hash_flags
808 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
810 /* We must copy these reloc types into the output file.
811 Create a reloc section in dynobj and make room for
818 name
= (bfd_elf_string_from_elf_section
820 elf_elfheader (abfd
)->e_shstrndx
,
821 elf_section_data (sec
)->rel_hdr
.sh_name
));
825 if (strncmp (name
, ".rel", 4) != 0
826 || strcmp (bfd_get_section_name (abfd
, sec
),
829 (*_bfd_error_handler
)
830 (_("%s: bad relocation section name `%s\'"),
831 bfd_archive_filename (abfd
), name
);
834 if (htab
->elf
.dynobj
== NULL
)
835 htab
->elf
.dynobj
= abfd
;
837 dynobj
= htab
->elf
.dynobj
;
838 sreloc
= bfd_get_section_by_name (dynobj
, name
);
843 sreloc
= bfd_make_section (dynobj
, name
);
844 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
845 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
846 if ((sec
->flags
& SEC_ALLOC
) != 0)
847 flags
|= SEC_ALLOC
| SEC_LOAD
;
849 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
850 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
853 elf_section_data (sec
)->sreloc
= sreloc
;
856 /* If this is a global symbol, we count the number of
857 relocations we need for this symbol. */
860 struct elf_i386_link_hash_entry
*eh
;
861 struct elf_i386_dyn_relocs
*p
;
863 eh
= (struct elf_i386_link_hash_entry
*) h
;
866 if (p
== NULL
|| p
->sec
!= sec
)
868 bfd_size_type amt
= sizeof *p
;
869 p
= ((struct elf_i386_dyn_relocs
*)
870 bfd_alloc (htab
->elf
.dynobj
, amt
));
873 p
->next
= eh
->dyn_relocs
;
881 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
886 /* Track dynamic relocs needed for local syms too. */
887 elf_section_data (sec
)->local_dynrel
+= 1;
892 /* This relocation describes the C++ object vtable hierarchy.
893 Reconstruct it for later use during GC. */
894 case R_386_GNU_VTINHERIT
:
895 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
899 /* This relocation describes which C++ vtable entries are actually
900 used. Record for later use during GC. */
901 case R_386_GNU_VTENTRY
:
902 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
914 /* Return the section that should be marked against GC for a given
918 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
920 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
921 Elf_Internal_Rela
*rel
;
922 struct elf_link_hash_entry
*h
;
923 Elf_Internal_Sym
*sym
;
927 switch (ELF32_R_TYPE (rel
->r_info
))
929 case R_386_GNU_VTINHERIT
:
930 case R_386_GNU_VTENTRY
:
934 switch (h
->root
.type
)
936 case bfd_link_hash_defined
:
937 case bfd_link_hash_defweak
:
938 return h
->root
.u
.def
.section
;
940 case bfd_link_hash_common
:
941 return h
->root
.u
.c
.p
->section
;
950 if (!(elf_bad_symtab (abfd
)
951 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
952 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
953 && sym
->st_shndx
!= SHN_COMMON
))
955 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
962 /* Update the got entry reference counts for the section being removed. */
965 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
967 struct bfd_link_info
*info
;
969 const Elf_Internal_Rela
*relocs
;
971 Elf_Internal_Shdr
*symtab_hdr
;
972 struct elf_link_hash_entry
**sym_hashes
;
973 bfd_signed_vma
*local_got_refcounts
;
974 const Elf_Internal_Rela
*rel
, *relend
;
975 unsigned long r_symndx
;
976 struct elf_link_hash_entry
*h
;
979 elf_section_data (sec
)->local_dynrel
= 0;
981 dynobj
= elf_hash_table (info
)->dynobj
;
985 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
986 sym_hashes
= elf_sym_hashes (abfd
);
987 local_got_refcounts
= elf_local_got_refcounts (abfd
);
989 relend
= relocs
+ sec
->reloc_count
;
990 for (rel
= relocs
; rel
< relend
; rel
++)
991 switch (ELF32_R_TYPE (rel
->r_info
))
996 r_symndx
= ELF32_R_SYM (rel
->r_info
);
997 if (r_symndx
>= symtab_hdr
->sh_info
)
999 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1000 if (h
->got
.refcount
> 0)
1001 h
->got
.refcount
-= 1;
1003 else if (local_got_refcounts
!= NULL
)
1005 if (local_got_refcounts
[r_symndx
] > 0)
1006 local_got_refcounts
[r_symndx
] -= 1;
1012 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1013 if (r_symndx
>= symtab_hdr
->sh_info
)
1015 struct elf_i386_link_hash_entry
*eh
;
1016 struct elf_i386_dyn_relocs
**pp
;
1017 struct elf_i386_dyn_relocs
*p
;
1019 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1021 if (!info
->shared
&& h
->plt
.refcount
> 0)
1022 h
->plt
.refcount
-= 1;
1024 eh
= (struct elf_i386_link_hash_entry
*) h
;
1026 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1029 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
1040 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1041 if (r_symndx
>= symtab_hdr
->sh_info
)
1043 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1044 if (h
->plt
.refcount
> 0)
1045 h
->plt
.refcount
-= 1;
1056 /* Adjust a symbol defined by a dynamic object and referenced by a
1057 regular object. The current definition is in some section of the
1058 dynamic object, but we're not including those sections. We have to
1059 change the definition to something the rest of the link can
1063 elf_i386_adjust_dynamic_symbol (info
, h
)
1064 struct bfd_link_info
*info
;
1065 struct elf_link_hash_entry
*h
;
1067 struct elf_i386_link_hash_table
*htab
;
1068 struct elf_i386_link_hash_entry
* eh
;
1069 struct elf_i386_dyn_relocs
*p
;
1071 unsigned int power_of_two
;
1073 /* If this is a function, put it in the procedure linkage table. We
1074 will fill in the contents of the procedure linkage table later,
1075 when we know the address of the .got section. */
1076 if (h
->type
== STT_FUNC
1077 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1079 if (h
->plt
.refcount
<= 0
1081 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1082 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
1084 /* This case can occur if we saw a PLT32 reloc in an input
1085 file, but the symbol was never referred to by a dynamic
1086 object, or if all references were garbage collected. In
1087 such a case, we don't actually need to build a procedure
1088 linkage table, and we can just do a PC32 reloc instead. */
1089 h
->plt
.refcount
= -1;
1090 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1096 /* It's possible that we incorrectly decided a .plt reloc was
1097 needed for an R_386_PC32 reloc to a non-function sym in
1098 check_relocs. We can't decide accurately between function and
1099 non-function syms in check-relocs; Objects loaded later in
1100 the link may change h->type. So fix it now. */
1101 h
->plt
.refcount
= -1;
1103 /* If this is a weak symbol, and there is a real definition, the
1104 processor independent code will have arranged for us to see the
1105 real definition first, and we can just use the same value. */
1106 if (h
->weakdef
!= NULL
)
1108 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1109 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1110 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1111 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1115 /* This is a reference to a symbol defined by a dynamic object which
1116 is not a function. */
1118 /* If we are creating a shared library, we must presume that the
1119 only references to the symbol are via the global offset table.
1120 For such cases we need not do anything here; the relocations will
1121 be handled correctly by relocate_section. */
1125 /* If there are no references to this symbol that do not use the
1126 GOT, we don't need to generate a copy reloc. */
1127 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1130 /* If -z nocopyreloc was given, we won't generate them either. */
1131 if (info
->nocopyreloc
)
1133 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1137 eh
= (struct elf_i386_link_hash_entry
*) h
;
1138 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1140 s
= p
->sec
->output_section
;
1141 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1145 /* If we didn't find any dynamic relocs in read-only sections, then
1146 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1149 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1153 /* We must allocate the symbol in our .dynbss section, which will
1154 become part of the .bss section of the executable. There will be
1155 an entry for this symbol in the .dynsym section. The dynamic
1156 object will contain position independent code, so all references
1157 from the dynamic object to this symbol will go through the global
1158 offset table. The dynamic linker will use the .dynsym entry to
1159 determine the address it must put in the global offset table, so
1160 both the dynamic object and the regular object will refer to the
1161 same memory location for the variable. */
1163 htab
= elf_i386_hash_table (info
);
1165 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1166 copy the initial value out of the dynamic object and into the
1167 runtime process image. */
1168 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1170 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rel
);
1171 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1174 /* We need to figure out the alignment required for this symbol. I
1175 have no idea how ELF linkers handle this. */
1176 power_of_two
= bfd_log2 (h
->size
);
1177 if (power_of_two
> 3)
1180 /* Apply the required alignment. */
1182 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1183 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1185 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1189 /* Define the symbol as being at this point in the section. */
1190 h
->root
.u
.def
.section
= s
;
1191 h
->root
.u
.def
.value
= s
->_raw_size
;
1193 /* Increment the section size to make room for the symbol. */
1194 s
->_raw_size
+= h
->size
;
1199 /* This is the condition under which elf_i386_finish_dynamic_symbol
1200 will be called from elflink.h. If elflink.h doesn't call our
1201 finish_dynamic_symbol routine, we'll need to do something about
1202 initializing any .plt and .got entries in elf_i386_relocate_section. */
1203 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1205 && ((INFO)->shared \
1206 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1207 && ((H)->dynindx != -1 \
1208 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1210 /* Allocate space in .plt, .got and associated reloc sections for
1214 allocate_dynrelocs (h
, inf
)
1215 struct elf_link_hash_entry
*h
;
1218 struct bfd_link_info
*info
;
1219 struct elf_i386_link_hash_table
*htab
;
1220 struct elf_i386_link_hash_entry
*eh
;
1221 struct elf_i386_dyn_relocs
*p
;
1223 if (h
->root
.type
== bfd_link_hash_indirect
1224 || h
->root
.type
== bfd_link_hash_warning
)
1227 info
= (struct bfd_link_info
*) inf
;
1228 htab
= elf_i386_hash_table (info
);
1230 if (htab
->elf
.dynamic_sections_created
1231 && h
->plt
.refcount
> 0)
1233 /* Make sure this symbol is output as a dynamic symbol.
1234 Undefined weak syms won't yet be marked as dynamic. */
1235 if (h
->dynindx
== -1
1236 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1238 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1242 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1244 asection
*s
= htab
->splt
;
1246 /* If this is the first .plt entry, make room for the special
1248 if (s
->_raw_size
== 0)
1249 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1251 h
->plt
.offset
= s
->_raw_size
;
1253 /* If this symbol is not defined in a regular file, and we are
1254 not generating a shared library, then set the symbol to this
1255 location in the .plt. This is required to make function
1256 pointers compare as equal between the normal executable and
1257 the shared library. */
1259 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1261 h
->root
.u
.def
.section
= s
;
1262 h
->root
.u
.def
.value
= h
->plt
.offset
;
1265 /* Make room for this entry. */
1266 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1268 /* We also need to make an entry in the .got.plt section, which
1269 will be placed in the .got section by the linker script. */
1270 htab
->sgotplt
->_raw_size
+= 4;
1272 /* We also need to make an entry in the .rel.plt section. */
1273 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
1277 h
->plt
.offset
= (bfd_vma
) -1;
1278 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1283 h
->plt
.offset
= (bfd_vma
) -1;
1284 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1287 if (h
->got
.refcount
> 0)
1292 /* Make sure this symbol is output as a dynamic symbol.
1293 Undefined weak syms won't yet be marked as dynamic. */
1294 if (h
->dynindx
== -1
1295 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1297 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1302 h
->got
.offset
= s
->_raw_size
;
1304 dyn
= htab
->elf
.dynamic_sections_created
;
1305 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1306 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1309 h
->got
.offset
= (bfd_vma
) -1;
1311 eh
= (struct elf_i386_link_hash_entry
*) h
;
1312 if (eh
->dyn_relocs
== NULL
)
1315 /* In the shared -Bsymbolic case, discard space allocated for
1316 dynamic pc-relative relocs against symbols which turn out to be
1317 defined in regular objects. For the normal shared case, discard
1318 space for pc-relative relocs that have become local due to symbol
1319 visibility changes. */
1323 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1324 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1327 struct elf_i386_dyn_relocs
**pp
;
1329 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1331 p
->count
-= p
->pc_count
;
1342 /* For the non-shared case, discard space for relocs against
1343 symbols which turn out to need copy relocs or are not
1346 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1347 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1348 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1349 || (htab
->elf
.dynamic_sections_created
1350 && (h
->root
.type
== bfd_link_hash_undefweak
1351 || h
->root
.type
== bfd_link_hash_undefined
))))
1353 /* Make sure this symbol is output as a dynamic symbol.
1354 Undefined weak syms won't yet be marked as dynamic. */
1355 if (h
->dynindx
== -1
1356 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1358 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1362 /* If that succeeded, we know we'll be keeping all the
1364 if (h
->dynindx
!= -1)
1368 eh
->dyn_relocs
= NULL
;
1373 /* Finally, allocate space. */
1374 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1376 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1377 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1383 /* Find any dynamic relocs that apply to read-only sections. */
1386 readonly_dynrelocs (h
, inf
)
1387 struct elf_link_hash_entry
*h
;
1390 struct elf_i386_link_hash_entry
*eh
;
1391 struct elf_i386_dyn_relocs
*p
;
1393 eh
= (struct elf_i386_link_hash_entry
*) h
;
1394 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1396 asection
*s
= p
->sec
->output_section
;
1398 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1400 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1402 info
->flags
|= DF_TEXTREL
;
1404 /* Not an error, just cut short the traversal. */
1411 /* Set the sizes of the dynamic sections. */
1414 elf_i386_size_dynamic_sections (output_bfd
, info
)
1415 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1416 struct bfd_link_info
*info
;
1418 struct elf_i386_link_hash_table
*htab
;
1424 htab
= elf_i386_hash_table (info
);
1425 dynobj
= htab
->elf
.dynobj
;
1429 if (htab
->elf
.dynamic_sections_created
)
1431 /* Set the contents of the .interp section to the interpreter. */
1434 s
= bfd_get_section_by_name (dynobj
, ".interp");
1437 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1438 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1442 /* Set up .got offsets for local syms, and space for local dynamic
1444 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1446 bfd_signed_vma
*local_got
;
1447 bfd_signed_vma
*end_local_got
;
1448 bfd_size_type locsymcount
;
1449 Elf_Internal_Shdr
*symtab_hdr
;
1452 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1455 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1457 bfd_size_type count
= elf_section_data (s
)->local_dynrel
;
1461 srel
= elf_section_data (s
)->sreloc
;
1462 srel
->_raw_size
+= count
* sizeof (Elf32_External_Rel
);
1466 local_got
= elf_local_got_refcounts (ibfd
);
1470 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1471 locsymcount
= symtab_hdr
->sh_info
;
1472 end_local_got
= local_got
+ locsymcount
;
1474 srel
= htab
->srelgot
;
1475 for (; local_got
< end_local_got
; ++local_got
)
1479 *local_got
= s
->_raw_size
;
1482 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1485 *local_got
= (bfd_vma
) -1;
1489 /* Allocate global sym .plt and .got entries, and space for global
1490 sym dynamic relocs. */
1491 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1493 /* We now have determined the sizes of the various dynamic sections.
1494 Allocate memory for them. */
1496 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1498 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1503 || s
== htab
->sgotplt
)
1505 /* Strip this section if we don't need it; see the
1508 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1510 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1513 /* We use the reloc_count field as a counter if we need
1514 to copy relocs into the output file. */
1519 /* It's not one of our sections, so don't allocate space. */
1523 if (s
->_raw_size
== 0)
1525 /* If we don't need this section, strip it from the
1526 output file. This is mostly to handle .rel.bss and
1527 .rel.plt. We must create both sections in
1528 create_dynamic_sections, because they must be created
1529 before the linker maps input sections to output
1530 sections. The linker does that before
1531 adjust_dynamic_symbol is called, and it is that
1532 function which decides whether anything needs to go
1533 into these sections. */
1535 _bfd_strip_section_from_output (info
, s
);
1539 /* Allocate memory for the section contents. We use bfd_zalloc
1540 here in case unused entries are not reclaimed before the
1541 section's contents are written out. This should not happen,
1542 but this way if it does, we get a R_386_NONE reloc instead
1544 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1545 if (s
->contents
== NULL
)
1549 if (htab
->elf
.dynamic_sections_created
)
1551 /* Add some entries to the .dynamic section. We fill in the
1552 values later, in elf_i386_finish_dynamic_sections, but we
1553 must add the entries now so that we get the correct size for
1554 the .dynamic section. The DT_DEBUG entry is filled in by the
1555 dynamic linker and used by the debugger. */
1556 #define add_dynamic_entry(TAG, VAL) \
1557 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1561 if (!add_dynamic_entry (DT_DEBUG
, 0))
1565 if (htab
->splt
->_raw_size
!= 0)
1567 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1568 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1569 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1570 || !add_dynamic_entry (DT_JMPREL
, 0))
1576 if (!add_dynamic_entry (DT_REL
, 0)
1577 || !add_dynamic_entry (DT_RELSZ
, 0)
1578 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1581 /* If any dynamic relocs apply to a read-only section,
1582 then we need a DT_TEXTREL entry. */
1583 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
1585 if ((info
->flags
& DF_TEXTREL
) != 0)
1587 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1592 #undef add_dynamic_entry
1597 /* Set the correct type for an x86 ELF section. We do this by the
1598 section name, which is a hack, but ought to work. */
1601 elf_i386_fake_sections (abfd
, hdr
, sec
)
1602 bfd
*abfd ATTRIBUTE_UNUSED
;
1603 Elf32_Internal_Shdr
*hdr
;
1606 register const char *name
;
1608 name
= bfd_get_section_name (abfd
, sec
);
1610 /* This is an ugly, but unfortunately necessary hack that is
1611 needed when producing EFI binaries on x86. It tells
1612 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1613 containing ELF relocation info. We need this hack in order to
1614 be able to generate ELF binaries that can be translated into
1615 EFI applications (which are essentially COFF objects). Those
1616 files contain a COFF ".reloc" section inside an ELFNN object,
1617 which would normally cause BFD to segfault because it would
1618 attempt to interpret this section as containing relocation
1619 entries for section "oc". With this hack enabled, ".reloc"
1620 will be treated as a normal data section, which will avoid the
1621 segfault. However, you won't be able to create an ELFNN binary
1622 with a section named "oc" that needs relocations, but that's
1623 the kind of ugly side-effects you get when detecting section
1624 types based on their names... In practice, this limitation is
1625 unlikely to bite. */
1626 if (strcmp (name
, ".reloc") == 0)
1627 hdr
->sh_type
= SHT_PROGBITS
;
1632 /* Relocate an i386 ELF section. */
1635 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1636 contents
, relocs
, local_syms
, local_sections
)
1638 struct bfd_link_info
*info
;
1640 asection
*input_section
;
1642 Elf_Internal_Rela
*relocs
;
1643 Elf_Internal_Sym
*local_syms
;
1644 asection
**local_sections
;
1646 struct elf_i386_link_hash_table
*htab
;
1647 Elf_Internal_Shdr
*symtab_hdr
;
1648 struct elf_link_hash_entry
**sym_hashes
;
1649 bfd_vma
*local_got_offsets
;
1650 Elf_Internal_Rela
*rel
;
1651 Elf_Internal_Rela
*relend
;
1653 htab
= elf_i386_hash_table (info
);
1654 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1655 sym_hashes
= elf_sym_hashes (input_bfd
);
1656 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1659 relend
= relocs
+ input_section
->reloc_count
;
1660 for (; rel
< relend
; rel
++)
1663 reloc_howto_type
*howto
;
1664 unsigned long r_symndx
;
1665 struct elf_link_hash_entry
*h
;
1666 Elf_Internal_Sym
*sym
;
1670 boolean unresolved_reloc
;
1671 bfd_reloc_status_type r
;
1674 r_type
= ELF32_R_TYPE (rel
->r_info
);
1675 if (r_type
== (int) R_386_GNU_VTINHERIT
1676 || r_type
== (int) R_386_GNU_VTENTRY
)
1679 if ((indx
= (unsigned) r_type
) >= R_386_standard
1680 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1681 >= R_386_ext
- R_386_standard
))
1683 bfd_set_error (bfd_error_bad_value
);
1686 howto
= elf_howto_table
+ indx
;
1688 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1690 if (info
->relocateable
)
1692 /* This is a relocatable link. We don't have to change
1693 anything, unless the reloc is against a section symbol,
1694 in which case we have to adjust according to where the
1695 section symbol winds up in the output section. */
1696 if (r_symndx
< symtab_hdr
->sh_info
)
1698 sym
= local_syms
+ r_symndx
;
1699 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1703 sec
= local_sections
[r_symndx
];
1704 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1705 val
+= sec
->output_offset
+ sym
->st_value
;
1706 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1712 /* This is a final link. */
1716 unresolved_reloc
= false;
1717 if (r_symndx
< symtab_hdr
->sh_info
)
1719 sym
= local_syms
+ r_symndx
;
1720 sec
= local_sections
[r_symndx
];
1721 relocation
= (sec
->output_section
->vma
1722 + sec
->output_offset
1727 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1728 while (h
->root
.type
== bfd_link_hash_indirect
1729 || h
->root
.type
== bfd_link_hash_warning
)
1730 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1733 if (h
->root
.type
== bfd_link_hash_defined
1734 || h
->root
.type
== bfd_link_hash_defweak
)
1736 sec
= h
->root
.u
.def
.section
;
1737 if (sec
->output_section
== NULL
)
1738 /* Set a flag that will be cleared later if we find a
1739 relocation value for this symbol. output_section
1740 is typically NULL for symbols satisfied by a shared
1742 unresolved_reloc
= true;
1744 relocation
= (h
->root
.u
.def
.value
1745 + sec
->output_section
->vma
1746 + sec
->output_offset
);
1748 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1750 else if (info
->shared
1751 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1752 && !info
->no_undefined
1753 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1757 if (! ((*info
->callbacks
->undefined_symbol
)
1758 (info
, h
->root
.root
.string
, input_bfd
,
1759 input_section
, rel
->r_offset
,
1760 (!info
->shared
|| info
->no_undefined
1761 || ELF_ST_VISIBILITY (h
->other
)))))
1769 /* Relocation is to the entry for this symbol in the global
1771 if (htab
->sgot
== NULL
)
1778 off
= h
->got
.offset
;
1779 dyn
= htab
->elf
.dynamic_sections_created
;
1780 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1784 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1785 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1787 /* This is actually a static link, or it is a
1788 -Bsymbolic link and the symbol is defined
1789 locally, or the symbol was forced to be local
1790 because of a version file. We must initialize
1791 this entry in the global offset table. Since the
1792 offset must always be a multiple of 4, we use the
1793 least significant bit to record whether we have
1794 initialized it already.
1796 When doing a dynamic link, we create a .rel.got
1797 relocation entry to initialize the value. This
1798 is done in the finish_dynamic_symbol routine. */
1803 bfd_put_32 (output_bfd
, relocation
,
1804 htab
->sgot
->contents
+ off
);
1809 unresolved_reloc
= false;
1813 if (local_got_offsets
== NULL
)
1816 off
= local_got_offsets
[r_symndx
];
1818 /* The offset must always be a multiple of 4. We use
1819 the least significant bit to record whether we have
1820 already generated the necessary reloc. */
1825 bfd_put_32 (output_bfd
, relocation
,
1826 htab
->sgot
->contents
+ off
);
1831 Elf_Internal_Rel outrel
;
1832 Elf32_External_Rel
*loc
;
1834 srelgot
= htab
->srelgot
;
1835 if (srelgot
== NULL
)
1838 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1839 + htab
->sgot
->output_offset
1841 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1842 loc
= (Elf32_External_Rel
*) srelgot
->contents
;
1843 loc
+= srelgot
->reloc_count
++;
1844 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1847 local_got_offsets
[r_symndx
] |= 1;
1851 if (off
>= (bfd_vma
) -2)
1854 relocation
= htab
->sgot
->output_offset
+ off
;
1858 /* Relocation is relative to the start of the global offset
1861 /* Note that sgot->output_offset is not involved in this
1862 calculation. We always want the start of .got. If we
1863 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1864 permitted by the ABI, we might have to change this
1866 relocation
-= htab
->sgot
->output_section
->vma
;
1870 /* Use global offset table as symbol value. */
1871 relocation
= htab
->sgot
->output_section
->vma
;
1872 unresolved_reloc
= false;
1876 /* Relocation is to the entry for this symbol in the
1877 procedure linkage table. */
1879 /* Resolve a PLT32 reloc against a local symbol directly,
1880 without using the procedure linkage table. */
1884 if (h
->plt
.offset
== (bfd_vma
) -1
1885 || htab
->splt
== NULL
)
1887 /* We didn't make a PLT entry for this symbol. This
1888 happens when statically linking PIC code, or when
1889 using -Bsymbolic. */
1893 relocation
= (htab
->splt
->output_section
->vma
1894 + htab
->splt
->output_offset
1896 unresolved_reloc
= false;
1902 && (input_section
->flags
& SEC_ALLOC
) != 0
1903 && (r_type
!= R_386_PC32
1906 && (! info
->symbolic
1907 || (h
->elf_link_hash_flags
1908 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1910 && (input_section
->flags
& SEC_ALLOC
) != 0
1913 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1914 && (((h
->elf_link_hash_flags
1915 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1916 && (h
->elf_link_hash_flags
1917 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1918 || h
->root
.type
== bfd_link_hash_undefweak
1919 || h
->root
.type
== bfd_link_hash_undefined
)))
1921 Elf_Internal_Rel outrel
;
1922 boolean skip
, relocate
;
1924 Elf32_External_Rel
*loc
;
1926 /* When generating a shared object, these relocations
1927 are copied into the output file to be resolved at run
1932 if (elf_section_data (input_section
)->stab_info
== NULL
)
1933 outrel
.r_offset
= rel
->r_offset
;
1936 off
= (_bfd_stab_section_offset
1937 (output_bfd
, htab
->elf
.stab_info
, input_section
,
1938 &elf_section_data (input_section
)->stab_info
,
1940 if (off
== (bfd_vma
) -1)
1942 outrel
.r_offset
= off
;
1945 outrel
.r_offset
+= (input_section
->output_section
->vma
1946 + input_section
->output_offset
);
1950 memset (&outrel
, 0, sizeof outrel
);
1955 && (r_type
== R_386_PC32
1958 || (h
->elf_link_hash_flags
1959 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1963 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1967 /* This symbol is local, or marked to become local. */
1969 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1972 sreloc
= elf_section_data (input_section
)->sreloc
;
1976 loc
= (Elf32_External_Rel
*) sreloc
->contents
;
1977 loc
+= sreloc
->reloc_count
++;
1978 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1980 /* If this reloc is against an external symbol, we do
1981 not want to fiddle with the addend. Otherwise, we
1982 need to include the symbol value so that it becomes
1983 an addend for the dynamic reloc. */
1994 /* FIXME: Why do we allow debugging sections to escape this error?
1995 More importantly, why do we not emit dynamic relocs for
1996 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1997 If we had emitted the dynamic reloc, we could remove the
1999 if (unresolved_reloc
2001 && (input_section
->flags
& SEC_DEBUGGING
) != 0
2002 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2003 (*_bfd_error_handler
)
2004 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2005 bfd_archive_filename (input_bfd
),
2006 bfd_get_section_name (input_bfd
, input_section
),
2007 (long) rel
->r_offset
,
2008 h
->root
.root
.string
);
2010 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2011 contents
, rel
->r_offset
,
2012 relocation
, (bfd_vma
) 0);
2019 case bfd_reloc_overflow
:
2024 name
= h
->root
.root
.string
;
2027 name
= bfd_elf_string_from_elf_section (input_bfd
,
2028 symtab_hdr
->sh_link
,
2033 name
= bfd_section_name (input_bfd
, sec
);
2035 if (! ((*info
->callbacks
->reloc_overflow
)
2036 (info
, name
, howto
->name
, (bfd_vma
) 0,
2037 input_bfd
, input_section
, rel
->r_offset
)))
2043 case bfd_reloc_outofrange
:
2052 /* Finish up dynamic symbol handling. We set the contents of various
2053 dynamic sections here. */
2056 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2058 struct bfd_link_info
*info
;
2059 struct elf_link_hash_entry
*h
;
2060 Elf_Internal_Sym
*sym
;
2062 struct elf_i386_link_hash_table
*htab
;
2064 htab
= elf_i386_hash_table (info
);
2066 if (h
->plt
.offset
!= (bfd_vma
) -1)
2070 Elf_Internal_Rel rel
;
2071 Elf32_External_Rel
*loc
;
2073 /* This symbol has an entry in the procedure linkage table. Set
2076 if (h
->dynindx
== -1
2077 || htab
->splt
== NULL
2078 || htab
->sgotplt
== NULL
2079 || htab
->srelplt
== NULL
)
2082 /* Get the index in the procedure linkage table which
2083 corresponds to this symbol. This is the index of this symbol
2084 in all the symbols for which we are making plt entries. The
2085 first entry in the procedure linkage table is reserved. */
2086 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2088 /* Get the offset into the .got table of the entry that
2089 corresponds to this function. Each .got entry is 4 bytes.
2090 The first three are reserved. */
2091 got_offset
= (plt_index
+ 3) * 4;
2093 /* Fill in the entry in the procedure linkage table. */
2096 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2098 bfd_put_32 (output_bfd
,
2099 (htab
->sgotplt
->output_section
->vma
2100 + htab
->sgotplt
->output_offset
2102 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2106 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2108 bfd_put_32 (output_bfd
, got_offset
,
2109 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2112 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2113 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2114 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2115 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2117 /* Fill in the entry in the global offset table. */
2118 bfd_put_32 (output_bfd
,
2119 (htab
->splt
->output_section
->vma
2120 + htab
->splt
->output_offset
2123 htab
->sgotplt
->contents
+ got_offset
);
2125 /* Fill in the entry in the .rel.plt section. */
2126 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2127 + htab
->sgotplt
->output_offset
2129 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2130 loc
= (Elf32_External_Rel
*) htab
->srelplt
->contents
+ plt_index
;
2131 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2133 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2135 /* Mark the symbol as undefined, rather than as defined in
2136 the .plt section. Leave the value alone. This is a clue
2137 for the dynamic linker, to make function pointer
2138 comparisons work between an application and shared
2140 sym
->st_shndx
= SHN_UNDEF
;
2144 if (h
->got
.offset
!= (bfd_vma
) -1)
2146 Elf_Internal_Rel rel
;
2147 Elf32_External_Rel
*loc
;
2149 /* This symbol has an entry in the global offset table. Set it
2152 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2155 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2156 + htab
->sgot
->output_offset
2157 + (h
->got
.offset
& ~(bfd_vma
) 1));
2159 /* If this is a static link, or it is a -Bsymbolic link and the
2160 symbol is defined locally or was forced to be local because
2161 of a version file, we just want to emit a RELATIVE reloc.
2162 The entry in the global offset table will already have been
2163 initialized in the relocate_section function. */
2167 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2168 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2170 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2171 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2175 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2176 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2177 htab
->sgot
->contents
+ h
->got
.offset
);
2178 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2181 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2182 loc
+= htab
->srelgot
->reloc_count
++;
2183 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2186 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2188 Elf_Internal_Rel rel
;
2189 Elf32_External_Rel
*loc
;
2191 /* This symbol needs a copy reloc. Set it up. */
2193 if (h
->dynindx
== -1
2194 || (h
->root
.type
!= bfd_link_hash_defined
2195 && h
->root
.type
!= bfd_link_hash_defweak
)
2196 || htab
->srelbss
== NULL
)
2199 rel
.r_offset
= (h
->root
.u
.def
.value
2200 + h
->root
.u
.def
.section
->output_section
->vma
2201 + h
->root
.u
.def
.section
->output_offset
);
2202 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2203 loc
= (Elf32_External_Rel
*) htab
->srelbss
->contents
;
2204 loc
+= htab
->srelbss
->reloc_count
++;
2205 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2208 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2209 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2210 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2211 sym
->st_shndx
= SHN_ABS
;
2216 /* Used to decide how to sort relocs in an optimal manner for the
2217 dynamic linker, before writing them out. */
2219 static enum elf_reloc_type_class
2220 elf_i386_reloc_type_class (rela
)
2221 const Elf_Internal_Rela
*rela
;
2223 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2225 case R_386_RELATIVE
:
2226 return reloc_class_relative
;
2227 case R_386_JUMP_SLOT
:
2228 return reloc_class_plt
;
2230 return reloc_class_copy
;
2232 return reloc_class_normal
;
2236 /* Finish up the dynamic sections. */
2239 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2241 struct bfd_link_info
*info
;
2243 struct elf_i386_link_hash_table
*htab
;
2247 htab
= elf_i386_hash_table (info
);
2248 dynobj
= htab
->elf
.dynobj
;
2249 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2251 if (htab
->elf
.dynamic_sections_created
)
2253 Elf32_External_Dyn
*dyncon
, *dynconend
;
2255 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2258 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2259 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2260 for (; dyncon
< dynconend
; dyncon
++)
2262 Elf_Internal_Dyn dyn
;
2265 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2273 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2277 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2281 s
= htab
->srelplt
->output_section
;
2282 if (s
->_cooked_size
!= 0)
2283 dyn
.d_un
.d_val
= s
->_cooked_size
;
2285 dyn
.d_un
.d_val
= s
->_raw_size
;
2289 /* My reading of the SVR4 ABI indicates that the
2290 procedure linkage table relocs (DT_JMPREL) should be
2291 included in the overall relocs (DT_REL). This is
2292 what Solaris does. However, UnixWare can not handle
2293 that case. Therefore, we override the DT_RELSZ entry
2294 here to make it not include the JMPREL relocs. Since
2295 the linker script arranges for .rel.plt to follow all
2296 other relocation sections, we don't have to worry
2297 about changing the DT_REL entry. */
2298 if (htab
->srelplt
!= NULL
)
2300 s
= htab
->srelplt
->output_section
;
2301 if (s
->_cooked_size
!= 0)
2302 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2304 dyn
.d_un
.d_val
-= s
->_raw_size
;
2309 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2312 /* Fill in the first entry in the procedure linkage table. */
2313 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2316 memcpy (htab
->splt
->contents
,
2317 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2320 memcpy (htab
->splt
->contents
,
2321 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2322 bfd_put_32 (output_bfd
,
2323 (htab
->sgotplt
->output_section
->vma
2324 + htab
->sgotplt
->output_offset
2326 htab
->splt
->contents
+ 2);
2327 bfd_put_32 (output_bfd
,
2328 (htab
->sgotplt
->output_section
->vma
2329 + htab
->sgotplt
->output_offset
2331 htab
->splt
->contents
+ 8);
2334 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2335 really seem like the right value. */
2336 elf_section_data (htab
->splt
->output_section
)
2337 ->this_hdr
.sh_entsize
= 4;
2343 /* Fill in the first three entries in the global offset table. */
2344 if (htab
->sgotplt
->_raw_size
> 0)
2346 bfd_put_32 (output_bfd
,
2347 (sdyn
== NULL
? (bfd_vma
) 0
2348 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2349 htab
->sgotplt
->contents
);
2350 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2351 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2354 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2359 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2360 #define TARGET_LITTLE_NAME "elf32-i386"
2361 #define ELF_ARCH bfd_arch_i386
2362 #define ELF_MACHINE_CODE EM_386
2363 #define ELF_MAXPAGESIZE 0x1000
2365 #define elf_backend_can_gc_sections 1
2366 #define elf_backend_can_refcount 1
2367 #define elf_backend_want_got_plt 1
2368 #define elf_backend_plt_readonly 1
2369 #define elf_backend_want_plt_sym 0
2370 #define elf_backend_got_header_size 12
2371 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2373 #define elf_info_to_howto elf_i386_info_to_howto
2374 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2376 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2377 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2378 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2380 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2381 #define elf_backend_check_relocs elf_i386_check_relocs
2382 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
2383 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2384 #define elf_backend_fake_sections elf_i386_fake_sections
2385 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2386 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2387 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2388 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2389 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2390 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2391 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2392 #define elf_backend_relocate_section elf_i386_relocate_section
2393 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2395 #include "elf32-target.h"