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 eh
= (struct elf_i386_link_hash_entry
*) h
;
1131 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1133 s
= p
->sec
->output_section
;
1134 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1138 /* If we didn't find any dynamic relocs in read-only sections, then
1139 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1142 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1146 /* We must allocate the symbol in our .dynbss section, which will
1147 become part of the .bss section of the executable. There will be
1148 an entry for this symbol in the .dynsym section. The dynamic
1149 object will contain position independent code, so all references
1150 from the dynamic object to this symbol will go through the global
1151 offset table. The dynamic linker will use the .dynsym entry to
1152 determine the address it must put in the global offset table, so
1153 both the dynamic object and the regular object will refer to the
1154 same memory location for the variable. */
1156 htab
= elf_i386_hash_table (info
);
1158 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1159 copy the initial value out of the dynamic object and into the
1160 runtime process image. */
1161 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1163 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rel
);
1164 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1167 /* We need to figure out the alignment required for this symbol. I
1168 have no idea how ELF linkers handle this. */
1169 power_of_two
= bfd_log2 (h
->size
);
1170 if (power_of_two
> 3)
1173 /* Apply the required alignment. */
1175 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1176 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1178 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1182 /* Define the symbol as being at this point in the section. */
1183 h
->root
.u
.def
.section
= s
;
1184 h
->root
.u
.def
.value
= s
->_raw_size
;
1186 /* Increment the section size to make room for the symbol. */
1187 s
->_raw_size
+= h
->size
;
1192 /* This is the condition under which elf_i386_finish_dynamic_symbol
1193 will be called from elflink.h. If elflink.h doesn't call our
1194 finish_dynamic_symbol routine, we'll need to do something about
1195 initializing any .plt and .got entries in elf_i386_relocate_section. */
1196 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1198 && ((INFO)->shared \
1199 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1200 && ((H)->dynindx != -1 \
1201 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1203 /* Allocate space in .plt, .got and associated reloc sections for
1207 allocate_dynrelocs (h
, inf
)
1208 struct elf_link_hash_entry
*h
;
1211 struct bfd_link_info
*info
;
1212 struct elf_i386_link_hash_table
*htab
;
1213 struct elf_i386_link_hash_entry
*eh
;
1214 struct elf_i386_dyn_relocs
*p
;
1216 if (h
->root
.type
== bfd_link_hash_indirect
1217 || h
->root
.type
== bfd_link_hash_warning
)
1220 info
= (struct bfd_link_info
*) inf
;
1221 htab
= elf_i386_hash_table (info
);
1223 if (htab
->elf
.dynamic_sections_created
1224 && h
->plt
.refcount
> 0)
1226 /* Make sure this symbol is output as a dynamic symbol.
1227 Undefined weak syms won't yet be marked as dynamic. */
1228 if (h
->dynindx
== -1
1229 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1231 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1235 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1237 asection
*s
= htab
->splt
;
1239 /* If this is the first .plt entry, make room for the special
1241 if (s
->_raw_size
== 0)
1242 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1244 h
->plt
.offset
= s
->_raw_size
;
1246 /* If this symbol is not defined in a regular file, and we are
1247 not generating a shared library, then set the symbol to this
1248 location in the .plt. This is required to make function
1249 pointers compare as equal between the normal executable and
1250 the shared library. */
1252 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1254 h
->root
.u
.def
.section
= s
;
1255 h
->root
.u
.def
.value
= h
->plt
.offset
;
1258 /* Make room for this entry. */
1259 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1261 /* We also need to make an entry in the .got.plt section, which
1262 will be placed in the .got section by the linker script. */
1263 htab
->sgotplt
->_raw_size
+= 4;
1265 /* We also need to make an entry in the .rel.plt section. */
1266 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
1270 h
->plt
.offset
= (bfd_vma
) -1;
1271 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1276 h
->plt
.offset
= (bfd_vma
) -1;
1277 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1280 if (h
->got
.refcount
> 0)
1285 /* Make sure this symbol is output as a dynamic symbol.
1286 Undefined weak syms won't yet be marked as dynamic. */
1287 if (h
->dynindx
== -1
1288 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1290 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1295 h
->got
.offset
= s
->_raw_size
;
1297 dyn
= htab
->elf
.dynamic_sections_created
;
1298 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1299 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1302 h
->got
.offset
= (bfd_vma
) -1;
1304 eh
= (struct elf_i386_link_hash_entry
*) h
;
1305 if (eh
->dyn_relocs
== NULL
)
1308 /* In the shared -Bsymbolic case, discard space allocated for
1309 dynamic pc-relative relocs against symbols which turn out to be
1310 defined in regular objects. For the normal shared case, discard
1311 space for pc-relative relocs that have become local due to symbol
1312 visibility changes. */
1316 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1317 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1320 struct elf_i386_dyn_relocs
**pp
;
1322 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1324 p
->count
-= p
->pc_count
;
1335 /* For the non-shared case, discard space for relocs against
1336 symbols which turn out to need copy relocs or are not
1339 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1340 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1341 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1342 || (htab
->elf
.dynamic_sections_created
1343 && (h
->root
.type
== bfd_link_hash_undefweak
1344 || h
->root
.type
== bfd_link_hash_undefined
))))
1346 /* Make sure this symbol is output as a dynamic symbol.
1347 Undefined weak syms won't yet be marked as dynamic. */
1348 if (h
->dynindx
== -1
1349 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1351 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1355 /* If that succeeded, we know we'll be keeping all the
1357 if (h
->dynindx
!= -1)
1361 eh
->dyn_relocs
= NULL
;
1366 /* Finally, allocate space. */
1367 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1369 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1370 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1376 /* Find any dynamic relocs that apply to read-only sections. */
1379 readonly_dynrelocs (h
, inf
)
1380 struct elf_link_hash_entry
*h
;
1383 struct elf_i386_link_hash_entry
*eh
;
1384 struct elf_i386_dyn_relocs
*p
;
1386 eh
= (struct elf_i386_link_hash_entry
*) h
;
1387 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1389 asection
*s
= p
->sec
->output_section
;
1391 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1393 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1395 info
->flags
|= DF_TEXTREL
;
1397 /* Not an error, just cut short the traversal. */
1404 /* Set the sizes of the dynamic sections. */
1407 elf_i386_size_dynamic_sections (output_bfd
, info
)
1408 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1409 struct bfd_link_info
*info
;
1411 struct elf_i386_link_hash_table
*htab
;
1417 htab
= elf_i386_hash_table (info
);
1418 dynobj
= htab
->elf
.dynobj
;
1422 if (htab
->elf
.dynamic_sections_created
)
1424 /* Set the contents of the .interp section to the interpreter. */
1427 s
= bfd_get_section_by_name (dynobj
, ".interp");
1430 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1431 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1435 /* Set up .got offsets for local syms, and space for local dynamic
1437 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1439 bfd_signed_vma
*local_got
;
1440 bfd_signed_vma
*end_local_got
;
1441 bfd_size_type locsymcount
;
1442 Elf_Internal_Shdr
*symtab_hdr
;
1445 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1448 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1450 bfd_size_type count
= elf_section_data (s
)->local_dynrel
;
1454 srel
= elf_section_data (s
)->sreloc
;
1455 srel
->_raw_size
+= count
* sizeof (Elf32_External_Rel
);
1459 local_got
= elf_local_got_refcounts (ibfd
);
1463 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1464 locsymcount
= symtab_hdr
->sh_info
;
1465 end_local_got
= local_got
+ locsymcount
;
1467 srel
= htab
->srelgot
;
1468 for (; local_got
< end_local_got
; ++local_got
)
1472 *local_got
= s
->_raw_size
;
1475 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1478 *local_got
= (bfd_vma
) -1;
1482 /* Allocate global sym .plt and .got entries, and space for global
1483 sym dynamic relocs. */
1484 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1486 /* We now have determined the sizes of the various dynamic sections.
1487 Allocate memory for them. */
1489 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1491 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1496 || s
== htab
->sgotplt
)
1498 /* Strip this section if we don't need it; see the
1501 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1503 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1506 /* We use the reloc_count field as a counter if we need
1507 to copy relocs into the output file. */
1512 /* It's not one of our sections, so don't allocate space. */
1516 if (s
->_raw_size
== 0)
1518 /* If we don't need this section, strip it from the
1519 output file. This is mostly to handle .rel.bss and
1520 .rel.plt. We must create both sections in
1521 create_dynamic_sections, because they must be created
1522 before the linker maps input sections to output
1523 sections. The linker does that before
1524 adjust_dynamic_symbol is called, and it is that
1525 function which decides whether anything needs to go
1526 into these sections. */
1528 _bfd_strip_section_from_output (info
, s
);
1532 /* Allocate memory for the section contents. We use bfd_zalloc
1533 here in case unused entries are not reclaimed before the
1534 section's contents are written out. This should not happen,
1535 but this way if it does, we get a R_386_NONE reloc instead
1537 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1538 if (s
->contents
== NULL
)
1542 if (htab
->elf
.dynamic_sections_created
)
1544 /* Add some entries to the .dynamic section. We fill in the
1545 values later, in elf_i386_finish_dynamic_sections, but we
1546 must add the entries now so that we get the correct size for
1547 the .dynamic section. The DT_DEBUG entry is filled in by the
1548 dynamic linker and used by the debugger. */
1549 #define add_dynamic_entry(TAG, VAL) \
1550 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1554 if (!add_dynamic_entry (DT_DEBUG
, 0))
1558 if (htab
->splt
->_raw_size
!= 0)
1560 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1561 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1562 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1563 || !add_dynamic_entry (DT_JMPREL
, 0))
1569 if (!add_dynamic_entry (DT_REL
, 0)
1570 || !add_dynamic_entry (DT_RELSZ
, 0)
1571 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1574 /* If any dynamic relocs apply to a read-only section,
1575 then we need a DT_TEXTREL entry. */
1576 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
1578 if ((info
->flags
& DF_TEXTREL
) != 0)
1580 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1585 #undef add_dynamic_entry
1590 /* Set the correct type for an x86 ELF section. We do this by the
1591 section name, which is a hack, but ought to work. */
1594 elf_i386_fake_sections (abfd
, hdr
, sec
)
1595 bfd
*abfd ATTRIBUTE_UNUSED
;
1596 Elf32_Internal_Shdr
*hdr
;
1599 register const char *name
;
1601 name
= bfd_get_section_name (abfd
, sec
);
1603 /* This is an ugly, but unfortunately necessary hack that is
1604 needed when producing EFI binaries on x86. It tells
1605 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1606 containing ELF relocation info. We need this hack in order to
1607 be able to generate ELF binaries that can be translated into
1608 EFI applications (which are essentially COFF objects). Those
1609 files contain a COFF ".reloc" section inside an ELFNN object,
1610 which would normally cause BFD to segfault because it would
1611 attempt to interpret this section as containing relocation
1612 entries for section "oc". With this hack enabled, ".reloc"
1613 will be treated as a normal data section, which will avoid the
1614 segfault. However, you won't be able to create an ELFNN binary
1615 with a section named "oc" that needs relocations, but that's
1616 the kind of ugly side-effects you get when detecting section
1617 types based on their names... In practice, this limitation is
1618 unlikely to bite. */
1619 if (strcmp (name
, ".reloc") == 0)
1620 hdr
->sh_type
= SHT_PROGBITS
;
1625 /* Relocate an i386 ELF section. */
1628 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1629 contents
, relocs
, local_syms
, local_sections
)
1631 struct bfd_link_info
*info
;
1633 asection
*input_section
;
1635 Elf_Internal_Rela
*relocs
;
1636 Elf_Internal_Sym
*local_syms
;
1637 asection
**local_sections
;
1639 struct elf_i386_link_hash_table
*htab
;
1640 Elf_Internal_Shdr
*symtab_hdr
;
1641 struct elf_link_hash_entry
**sym_hashes
;
1642 bfd_vma
*local_got_offsets
;
1643 Elf_Internal_Rela
*rel
;
1644 Elf_Internal_Rela
*relend
;
1646 htab
= elf_i386_hash_table (info
);
1647 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1648 sym_hashes
= elf_sym_hashes (input_bfd
);
1649 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1652 relend
= relocs
+ input_section
->reloc_count
;
1653 for (; rel
< relend
; rel
++)
1656 reloc_howto_type
*howto
;
1657 unsigned long r_symndx
;
1658 struct elf_link_hash_entry
*h
;
1659 Elf_Internal_Sym
*sym
;
1663 boolean unresolved_reloc
;
1664 bfd_reloc_status_type r
;
1667 r_type
= ELF32_R_TYPE (rel
->r_info
);
1668 if (r_type
== (int) R_386_GNU_VTINHERIT
1669 || r_type
== (int) R_386_GNU_VTENTRY
)
1672 if ((indx
= (unsigned) r_type
) >= R_386_standard
1673 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1674 >= R_386_ext
- R_386_standard
))
1676 bfd_set_error (bfd_error_bad_value
);
1679 howto
= elf_howto_table
+ indx
;
1681 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1683 if (info
->relocateable
)
1685 /* This is a relocatable link. We don't have to change
1686 anything, unless the reloc is against a section symbol,
1687 in which case we have to adjust according to where the
1688 section symbol winds up in the output section. */
1689 if (r_symndx
< symtab_hdr
->sh_info
)
1691 sym
= local_syms
+ r_symndx
;
1692 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1696 sec
= local_sections
[r_symndx
];
1697 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1698 val
+= sec
->output_offset
+ sym
->st_value
;
1699 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1705 /* This is a final link. */
1709 unresolved_reloc
= false;
1710 if (r_symndx
< symtab_hdr
->sh_info
)
1712 sym
= local_syms
+ r_symndx
;
1713 sec
= local_sections
[r_symndx
];
1714 relocation
= (sec
->output_section
->vma
1715 + sec
->output_offset
1720 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1721 while (h
->root
.type
== bfd_link_hash_indirect
1722 || h
->root
.type
== bfd_link_hash_warning
)
1723 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1726 if (h
->root
.type
== bfd_link_hash_defined
1727 || h
->root
.type
== bfd_link_hash_defweak
)
1729 sec
= h
->root
.u
.def
.section
;
1730 if (sec
->output_section
== NULL
)
1731 /* Set a flag that will be cleared later if we find a
1732 relocation value for this symbol. output_section
1733 is typically NULL for symbols satisfied by a shared
1735 unresolved_reloc
= true;
1737 relocation
= (h
->root
.u
.def
.value
1738 + sec
->output_section
->vma
1739 + sec
->output_offset
);
1741 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1743 else if (info
->shared
1744 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1745 && !info
->no_undefined
1746 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1750 if (! ((*info
->callbacks
->undefined_symbol
)
1751 (info
, h
->root
.root
.string
, input_bfd
,
1752 input_section
, rel
->r_offset
,
1753 (!info
->shared
|| info
->no_undefined
1754 || ELF_ST_VISIBILITY (h
->other
)))))
1762 /* Relocation is to the entry for this symbol in the global
1764 if (htab
->sgot
== NULL
)
1771 off
= h
->got
.offset
;
1772 dyn
= htab
->elf
.dynamic_sections_created
;
1773 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1777 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1778 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1780 /* This is actually a static link, or it is a
1781 -Bsymbolic link and the symbol is defined
1782 locally, or the symbol was forced to be local
1783 because of a version file. We must initialize
1784 this entry in the global offset table. Since the
1785 offset must always be a multiple of 4, we use the
1786 least significant bit to record whether we have
1787 initialized it already.
1789 When doing a dynamic link, we create a .rel.got
1790 relocation entry to initialize the value. This
1791 is done in the finish_dynamic_symbol routine. */
1796 bfd_put_32 (output_bfd
, relocation
,
1797 htab
->sgot
->contents
+ off
);
1802 unresolved_reloc
= false;
1806 if (local_got_offsets
== NULL
)
1809 off
= local_got_offsets
[r_symndx
];
1811 /* The offset must always be a multiple of 4. We use
1812 the least significant bit to record whether we have
1813 already generated the necessary reloc. */
1818 bfd_put_32 (output_bfd
, relocation
,
1819 htab
->sgot
->contents
+ off
);
1824 Elf_Internal_Rel outrel
;
1825 Elf32_External_Rel
*loc
;
1827 srelgot
= htab
->srelgot
;
1828 if (srelgot
== NULL
)
1831 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1832 + htab
->sgot
->output_offset
1834 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1835 loc
= (Elf32_External_Rel
*) srelgot
->contents
;
1836 loc
+= srelgot
->reloc_count
++;
1837 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1840 local_got_offsets
[r_symndx
] |= 1;
1844 if (off
>= (bfd_vma
) -2)
1847 relocation
= htab
->sgot
->output_offset
+ off
;
1851 /* Relocation is relative to the start of the global offset
1854 /* Note that sgot->output_offset is not involved in this
1855 calculation. We always want the start of .got. If we
1856 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1857 permitted by the ABI, we might have to change this
1859 relocation
-= htab
->sgot
->output_section
->vma
;
1863 /* Use global offset table as symbol value. */
1864 relocation
= htab
->sgot
->output_section
->vma
;
1865 unresolved_reloc
= false;
1869 /* Relocation is to the entry for this symbol in the
1870 procedure linkage table. */
1872 /* Resolve a PLT32 reloc against a local symbol directly,
1873 without using the procedure linkage table. */
1877 if (h
->plt
.offset
== (bfd_vma
) -1
1878 || htab
->splt
== NULL
)
1880 /* We didn't make a PLT entry for this symbol. This
1881 happens when statically linking PIC code, or when
1882 using -Bsymbolic. */
1886 relocation
= (htab
->splt
->output_section
->vma
1887 + htab
->splt
->output_offset
1889 unresolved_reloc
= false;
1895 && (input_section
->flags
& SEC_ALLOC
) != 0
1896 && (r_type
!= R_386_PC32
1899 && (! info
->symbolic
1900 || (h
->elf_link_hash_flags
1901 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1903 && (input_section
->flags
& SEC_ALLOC
) != 0
1906 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1907 && (((h
->elf_link_hash_flags
1908 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1909 && (h
->elf_link_hash_flags
1910 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1911 || h
->root
.type
== bfd_link_hash_undefweak
1912 || h
->root
.type
== bfd_link_hash_undefined
)))
1914 Elf_Internal_Rel outrel
;
1915 boolean skip
, relocate
;
1917 Elf32_External_Rel
*loc
;
1919 /* When generating a shared object, these relocations
1920 are copied into the output file to be resolved at run
1925 if (elf_section_data (input_section
)->stab_info
== NULL
)
1926 outrel
.r_offset
= rel
->r_offset
;
1929 off
= (_bfd_stab_section_offset
1930 (output_bfd
, htab
->elf
.stab_info
, input_section
,
1931 &elf_section_data (input_section
)->stab_info
,
1933 if (off
== (bfd_vma
) -1)
1935 outrel
.r_offset
= off
;
1938 outrel
.r_offset
+= (input_section
->output_section
->vma
1939 + input_section
->output_offset
);
1943 memset (&outrel
, 0, sizeof outrel
);
1948 && (r_type
== R_386_PC32
1951 || (h
->elf_link_hash_flags
1952 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1956 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1960 /* This symbol is local, or marked to become local. */
1962 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1965 sreloc
= elf_section_data (input_section
)->sreloc
;
1969 loc
= (Elf32_External_Rel
*) sreloc
->contents
;
1970 loc
+= sreloc
->reloc_count
++;
1971 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1973 /* If this reloc is against an external symbol, we do
1974 not want to fiddle with the addend. Otherwise, we
1975 need to include the symbol value so that it becomes
1976 an addend for the dynamic reloc. */
1987 /* FIXME: Why do we allow debugging sections to escape this error?
1988 More importantly, why do we not emit dynamic relocs for
1989 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1990 If we had emitted the dynamic reloc, we could remove the
1992 if (unresolved_reloc
1994 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1995 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1996 (*_bfd_error_handler
)
1997 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1998 bfd_archive_filename (input_bfd
),
1999 bfd_get_section_name (input_bfd
, input_section
),
2000 (long) rel
->r_offset
,
2001 h
->root
.root
.string
);
2003 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2004 contents
, rel
->r_offset
,
2005 relocation
, (bfd_vma
) 0);
2012 case bfd_reloc_overflow
:
2017 name
= h
->root
.root
.string
;
2020 name
= bfd_elf_string_from_elf_section (input_bfd
,
2021 symtab_hdr
->sh_link
,
2026 name
= bfd_section_name (input_bfd
, sec
);
2028 if (! ((*info
->callbacks
->reloc_overflow
)
2029 (info
, name
, howto
->name
, (bfd_vma
) 0,
2030 input_bfd
, input_section
, rel
->r_offset
)))
2036 case bfd_reloc_outofrange
:
2045 /* Finish up dynamic symbol handling. We set the contents of various
2046 dynamic sections here. */
2049 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2051 struct bfd_link_info
*info
;
2052 struct elf_link_hash_entry
*h
;
2053 Elf_Internal_Sym
*sym
;
2055 struct elf_i386_link_hash_table
*htab
;
2057 htab
= elf_i386_hash_table (info
);
2059 if (h
->plt
.offset
!= (bfd_vma
) -1)
2063 Elf_Internal_Rel rel
;
2064 Elf32_External_Rel
*loc
;
2066 /* This symbol has an entry in the procedure linkage table. Set
2069 if (h
->dynindx
== -1
2070 || htab
->splt
== NULL
2071 || htab
->sgotplt
== NULL
2072 || htab
->srelplt
== NULL
)
2075 /* Get the index in the procedure linkage table which
2076 corresponds to this symbol. This is the index of this symbol
2077 in all the symbols for which we are making plt entries. The
2078 first entry in the procedure linkage table is reserved. */
2079 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2081 /* Get the offset into the .got table of the entry that
2082 corresponds to this function. Each .got entry is 4 bytes.
2083 The first three are reserved. */
2084 got_offset
= (plt_index
+ 3) * 4;
2086 /* Fill in the entry in the procedure linkage table. */
2089 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2091 bfd_put_32 (output_bfd
,
2092 (htab
->sgotplt
->output_section
->vma
2093 + htab
->sgotplt
->output_offset
2095 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2099 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2101 bfd_put_32 (output_bfd
, got_offset
,
2102 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2105 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2106 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2107 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2108 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2110 /* Fill in the entry in the global offset table. */
2111 bfd_put_32 (output_bfd
,
2112 (htab
->splt
->output_section
->vma
2113 + htab
->splt
->output_offset
2116 htab
->sgotplt
->contents
+ got_offset
);
2118 /* Fill in the entry in the .rel.plt section. */
2119 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2120 + htab
->sgotplt
->output_offset
2122 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2123 loc
= (Elf32_External_Rel
*) htab
->srelplt
->contents
+ plt_index
;
2124 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2126 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2128 /* Mark the symbol as undefined, rather than as defined in
2129 the .plt section. Leave the value alone. This is a clue
2130 for the dynamic linker, to make function pointer
2131 comparisons work between an application and shared
2133 sym
->st_shndx
= SHN_UNDEF
;
2137 if (h
->got
.offset
!= (bfd_vma
) -1)
2139 Elf_Internal_Rel rel
;
2140 Elf32_External_Rel
*loc
;
2142 /* This symbol has an entry in the global offset table. Set it
2145 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2148 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2149 + htab
->sgot
->output_offset
2150 + (h
->got
.offset
& ~(bfd_vma
) 1));
2152 /* If this is a static link, or it is a -Bsymbolic link and the
2153 symbol is defined locally or was forced to be local because
2154 of a version file, we just want to emit a RELATIVE reloc.
2155 The entry in the global offset table will already have been
2156 initialized in the relocate_section function. */
2160 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2161 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2163 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2164 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2168 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2169 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2170 htab
->sgot
->contents
+ h
->got
.offset
);
2171 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2174 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2175 loc
+= htab
->srelgot
->reloc_count
++;
2176 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2179 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2181 Elf_Internal_Rel rel
;
2182 Elf32_External_Rel
*loc
;
2184 /* This symbol needs a copy reloc. Set it up. */
2186 if (h
->dynindx
== -1
2187 || (h
->root
.type
!= bfd_link_hash_defined
2188 && h
->root
.type
!= bfd_link_hash_defweak
)
2189 || htab
->srelbss
== NULL
)
2192 rel
.r_offset
= (h
->root
.u
.def
.value
2193 + h
->root
.u
.def
.section
->output_section
->vma
2194 + h
->root
.u
.def
.section
->output_offset
);
2195 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2196 loc
= (Elf32_External_Rel
*) htab
->srelbss
->contents
;
2197 loc
+= htab
->srelbss
->reloc_count
++;
2198 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2201 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2202 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2203 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2204 sym
->st_shndx
= SHN_ABS
;
2209 /* Used to decide how to sort relocs in an optimal manner for the
2210 dynamic linker, before writing them out. */
2212 static enum elf_reloc_type_class
2213 elf_i386_reloc_type_class (rela
)
2214 const Elf_Internal_Rela
*rela
;
2216 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2218 case R_386_RELATIVE
:
2219 return reloc_class_relative
;
2220 case R_386_JUMP_SLOT
:
2221 return reloc_class_plt
;
2223 return reloc_class_copy
;
2225 return reloc_class_normal
;
2229 /* Finish up the dynamic sections. */
2232 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2234 struct bfd_link_info
*info
;
2236 struct elf_i386_link_hash_table
*htab
;
2240 htab
= elf_i386_hash_table (info
);
2241 dynobj
= htab
->elf
.dynobj
;
2242 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2244 if (htab
->elf
.dynamic_sections_created
)
2246 Elf32_External_Dyn
*dyncon
, *dynconend
;
2248 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2251 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2252 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2253 for (; dyncon
< dynconend
; dyncon
++)
2255 Elf_Internal_Dyn dyn
;
2258 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2266 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2270 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2274 s
= htab
->srelplt
->output_section
;
2275 if (s
->_cooked_size
!= 0)
2276 dyn
.d_un
.d_val
= s
->_cooked_size
;
2278 dyn
.d_un
.d_val
= s
->_raw_size
;
2282 /* My reading of the SVR4 ABI indicates that the
2283 procedure linkage table relocs (DT_JMPREL) should be
2284 included in the overall relocs (DT_REL). This is
2285 what Solaris does. However, UnixWare can not handle
2286 that case. Therefore, we override the DT_RELSZ entry
2287 here to make it not include the JMPREL relocs. Since
2288 the linker script arranges for .rel.plt to follow all
2289 other relocation sections, we don't have to worry
2290 about changing the DT_REL entry. */
2291 if (htab
->srelplt
!= NULL
)
2293 s
= htab
->srelplt
->output_section
;
2294 if (s
->_cooked_size
!= 0)
2295 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2297 dyn
.d_un
.d_val
-= s
->_raw_size
;
2302 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2305 /* Fill in the first entry in the procedure linkage table. */
2306 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2309 memcpy (htab
->splt
->contents
,
2310 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2313 memcpy (htab
->splt
->contents
,
2314 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2315 bfd_put_32 (output_bfd
,
2316 (htab
->sgotplt
->output_section
->vma
2317 + htab
->sgotplt
->output_offset
2319 htab
->splt
->contents
+ 2);
2320 bfd_put_32 (output_bfd
,
2321 (htab
->sgotplt
->output_section
->vma
2322 + htab
->sgotplt
->output_offset
2324 htab
->splt
->contents
+ 8);
2327 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2328 really seem like the right value. */
2329 elf_section_data (htab
->splt
->output_section
)
2330 ->this_hdr
.sh_entsize
= 4;
2336 /* Fill in the first three entries in the global offset table. */
2337 if (htab
->sgotplt
->_raw_size
> 0)
2339 bfd_put_32 (output_bfd
,
2340 (sdyn
== NULL
? (bfd_vma
) 0
2341 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2342 htab
->sgotplt
->contents
);
2343 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2344 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2347 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2352 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2353 #define TARGET_LITTLE_NAME "elf32-i386"
2354 #define ELF_ARCH bfd_arch_i386
2355 #define ELF_MACHINE_CODE EM_386
2356 #define ELF_MAXPAGESIZE 0x1000
2358 #define elf_backend_can_gc_sections 1
2359 #define elf_backend_can_refcount 1
2360 #define elf_backend_want_got_plt 1
2361 #define elf_backend_plt_readonly 1
2362 #define elf_backend_want_plt_sym 0
2363 #define elf_backend_got_header_size 12
2364 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2366 #define elf_info_to_howto elf_i386_info_to_howto
2367 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2369 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2370 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2371 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2373 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2374 #define elf_backend_check_relocs elf_i386_check_relocs
2375 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
2376 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2377 #define elf_backend_fake_sections elf_i386_fake_sections
2378 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2379 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2380 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2381 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2382 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2383 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2384 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2385 #define elf_backend_relocate_section elf_i386_relocate_section
2386 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2388 #include "elf32-target.h"