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
*));
48 elf_i386_copy_indirect_symbol
49 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
50 static boolean elf_i386_check_relocs
51 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
52 const Elf_Internal_Rela
*));
53 static asection
*elf_i386_gc_mark_hook
54 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
55 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
56 static boolean elf_i386_gc_sweep_hook
57 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
58 const Elf_Internal_Rela
*));
59 static boolean elf_i386_adjust_dynamic_symbol
60 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
61 static boolean allocate_dynrelocs
62 PARAMS ((struct elf_link_hash_entry
*, PTR
));
63 static boolean readonly_dynrelocs
64 PARAMS ((struct elf_link_hash_entry
*, PTR
));
65 static boolean elf_i386_fake_sections
66 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, asection
*));
67 static boolean elf_i386_size_dynamic_sections
68 PARAMS ((bfd
*, struct bfd_link_info
*));
69 static boolean elf_i386_relocate_section
70 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
71 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
72 static boolean elf_i386_finish_dynamic_symbol
73 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
75 static enum elf_reloc_type_class elf_i386_reloc_type_class
76 PARAMS ((const Elf_Internal_Rela
*));
77 static boolean elf_i386_finish_dynamic_sections
78 PARAMS ((bfd
*, struct bfd_link_info
*));
80 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
84 static reloc_howto_type elf_howto_table
[]=
86 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_386_NONE",
88 true, 0x00000000, 0x00000000, false),
89 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_386_32",
91 true, 0xffffffff, 0xffffffff, false),
92 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_386_PC32",
94 true, 0xffffffff, 0xffffffff, true),
95 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_386_GOT32",
97 true, 0xffffffff, 0xffffffff, false),
98 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_386_PLT32",
100 true, 0xffffffff, 0xffffffff, true),
101 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_386_COPY",
103 true, 0xffffffff, 0xffffffff, false),
104 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
106 true, 0xffffffff, 0xffffffff, false),
107 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
109 true, 0xffffffff, 0xffffffff, false),
110 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
111 bfd_elf_generic_reloc
, "R_386_RELATIVE",
112 true, 0xffffffff, 0xffffffff, false),
113 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
114 bfd_elf_generic_reloc
, "R_386_GOTOFF",
115 true, 0xffffffff, 0xffffffff, false),
116 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
117 bfd_elf_generic_reloc
, "R_386_GOTPC",
118 true, 0xffffffff, 0xffffffff, true),
120 /* We have a gap in the reloc numbers here.
121 R_386_standard counts the number up to this point, and
122 R_386_ext_offset is the value to subtract from a reloc type of
123 R_386_16 thru R_386_PC8 to form an index into this table. */
124 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
125 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
127 /* The remaining relocs are a GNU extension. */
128 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
129 bfd_elf_generic_reloc
, "R_386_16",
130 true, 0xffff, 0xffff, false),
131 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
132 bfd_elf_generic_reloc
, "R_386_PC16",
133 true, 0xffff, 0xffff, true),
134 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
135 bfd_elf_generic_reloc
, "R_386_8",
136 true, 0xff, 0xff, false),
137 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_386_PC8",
139 true, 0xff, 0xff, true),
142 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
143 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
145 /* GNU extension to record C++ vtable hierarchy. */
146 HOWTO (R_386_GNU_VTINHERIT
, /* type */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
150 false, /* pc_relative */
152 complain_overflow_dont
, /* complain_on_overflow */
153 NULL
, /* special_function */
154 "R_386_GNU_VTINHERIT", /* name */
155 false, /* partial_inplace */
160 /* GNU extension to record C++ vtable member usage. */
161 HOWTO (R_386_GNU_VTENTRY
, /* type */
163 2, /* size (0 = byte, 1 = short, 2 = long) */
165 false, /* pc_relative */
167 complain_overflow_dont
, /* complain_on_overflow */
168 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
169 "R_386_GNU_VTENTRY", /* name */
170 false, /* partial_inplace */
175 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
179 #ifdef DEBUG_GEN_RELOC
180 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
185 static reloc_howto_type
*
186 elf_i386_reloc_type_lookup (abfd
, code
)
187 bfd
*abfd ATTRIBUTE_UNUSED
;
188 bfd_reloc_code_real_type code
;
193 TRACE ("BFD_RELOC_NONE");
194 return &elf_howto_table
[(unsigned int) R_386_NONE
];
197 TRACE ("BFD_RELOC_32");
198 return &elf_howto_table
[(unsigned int) R_386_32
];
201 TRACE ("BFD_RELOC_CTOR");
202 return &elf_howto_table
[(unsigned int) R_386_32
];
204 case BFD_RELOC_32_PCREL
:
205 TRACE ("BFD_RELOC_PC32");
206 return &elf_howto_table
[(unsigned int) R_386_PC32
];
208 case BFD_RELOC_386_GOT32
:
209 TRACE ("BFD_RELOC_386_GOT32");
210 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
212 case BFD_RELOC_386_PLT32
:
213 TRACE ("BFD_RELOC_386_PLT32");
214 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
216 case BFD_RELOC_386_COPY
:
217 TRACE ("BFD_RELOC_386_COPY");
218 return &elf_howto_table
[(unsigned int) R_386_COPY
];
220 case BFD_RELOC_386_GLOB_DAT
:
221 TRACE ("BFD_RELOC_386_GLOB_DAT");
222 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
224 case BFD_RELOC_386_JUMP_SLOT
:
225 TRACE ("BFD_RELOC_386_JUMP_SLOT");
226 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
228 case BFD_RELOC_386_RELATIVE
:
229 TRACE ("BFD_RELOC_386_RELATIVE");
230 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
232 case BFD_RELOC_386_GOTOFF
:
233 TRACE ("BFD_RELOC_386_GOTOFF");
234 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
236 case BFD_RELOC_386_GOTPC
:
237 TRACE ("BFD_RELOC_386_GOTPC");
238 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
240 /* The remaining relocs are a GNU extension. */
242 TRACE ("BFD_RELOC_16");
243 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
245 case BFD_RELOC_16_PCREL
:
246 TRACE ("BFD_RELOC_16_PCREL");
247 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
250 TRACE ("BFD_RELOC_8");
251 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
253 case BFD_RELOC_8_PCREL
:
254 TRACE ("BFD_RELOC_8_PCREL");
255 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
257 case BFD_RELOC_VTABLE_INHERIT
:
258 TRACE ("BFD_RELOC_VTABLE_INHERIT");
259 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
262 case BFD_RELOC_VTABLE_ENTRY
:
263 TRACE ("BFD_RELOC_VTABLE_ENTRY");
264 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
276 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
277 bfd
*abfd ATTRIBUTE_UNUSED
;
278 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
279 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
285 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
286 bfd
*abfd ATTRIBUTE_UNUSED
;
288 Elf32_Internal_Rel
*dst
;
290 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
293 if ((indx
= r_type
) >= R_386_standard
294 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
295 >= R_386_ext
- R_386_standard
)
296 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
297 >= R_386_vt
- R_386_ext
))
299 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
300 bfd_archive_filename (abfd
), (int) r_type
);
301 indx
= (unsigned int) R_386_NONE
;
303 cache_ptr
->howto
= &elf_howto_table
[indx
];
306 /* Return whether a symbol name implies a local label. The UnixWare
307 2.1 cc generates temporary symbols that start with .X, so we
308 recognize them here. FIXME: do other SVR4 compilers also use .X?.
309 If so, we should move the .X recognition into
310 _bfd_elf_is_local_label_name. */
313 elf_i386_is_local_label_name (abfd
, name
)
317 if (name
[0] == '.' && name
[1] == 'X')
320 return _bfd_elf_is_local_label_name (abfd
, name
);
323 /* Support for core dump NOTE sections. */
325 elf_i386_grok_prstatus (abfd
, note
)
327 Elf_Internal_Note
*note
;
332 switch (note
->descsz
)
337 case 144: /* Linux/i386 */
339 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
342 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
351 /* Make a ".reg/999" section. */
352 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
353 raw_size
, note
->descpos
+ offset
);
357 elf_i386_grok_psinfo (abfd
, note
)
359 Elf_Internal_Note
*note
;
361 switch (note
->descsz
)
366 case 128: /* Linux/MIPS elf_prpsinfo */
367 elf_tdata (abfd
)->core_program
368 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
369 elf_tdata (abfd
)->core_command
370 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
373 /* Note that for some reason, a spurious space is tacked
374 onto the end of the args in some (at least one anyway)
375 implementations, so strip it off if it exists. */
378 char *command
= elf_tdata (abfd
)->core_command
;
379 int n
= strlen (command
);
381 if (0 < n
&& command
[n
- 1] == ' ')
382 command
[n
- 1] = '\0';
388 /* Functions for the i386 ELF linker.
390 In order to gain some understanding of code in this file without
391 knowing all the intricate details of the linker, note the
394 Functions named elf_i386_* are called by external routines, other
395 functions are only called locally. elf_i386_* functions appear
396 in this file more or less in the order in which they are called
397 from external routines. eg. elf_i386_check_relocs is called
398 early in the link process, elf_i386_finish_dynamic_sections is
399 one of the last functions. */
402 /* The name of the dynamic interpreter. This is put in the .interp
405 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
407 /* The size in bytes of an entry in the procedure linkage table. */
409 #define PLT_ENTRY_SIZE 16
411 /* The first entry in an absolute procedure linkage table looks like
412 this. See the SVR4 ABI i386 supplement to see how this works. */
414 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
416 0xff, 0x35, /* pushl contents of address */
417 0, 0, 0, 0, /* replaced with address of .got + 4. */
418 0xff, 0x25, /* jmp indirect */
419 0, 0, 0, 0, /* replaced with address of .got + 8. */
420 0, 0, 0, 0 /* pad out to 16 bytes. */
423 /* Subsequent entries in an absolute procedure linkage table look like
426 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
428 0xff, 0x25, /* jmp indirect */
429 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
430 0x68, /* pushl immediate */
431 0, 0, 0, 0, /* replaced with offset into relocation table. */
432 0xe9, /* jmp relative */
433 0, 0, 0, 0 /* replaced with offset to start of .plt. */
436 /* The first entry in a PIC procedure linkage table look like this. */
438 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
440 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
441 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
442 0, 0, 0, 0 /* pad out to 16 bytes. */
445 /* Subsequent entries in a PIC procedure linkage table look like this. */
447 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
449 0xff, 0xa3, /* jmp *offset(%ebx) */
450 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
451 0x68, /* pushl immediate */
452 0, 0, 0, 0, /* replaced with offset into relocation table. */
453 0xe9, /* jmp relative */
454 0, 0, 0, 0 /* replaced with offset to start of .plt. */
457 /* The i386 linker needs to keep track of the number of relocs that it
458 decides to copy as dynamic relocs in check_relocs for each symbol.
459 This is so that it can later discard them if they are found to be
460 unnecessary. We store the information in a field extending the
461 regular ELF linker hash table. */
463 struct elf_i386_dyn_relocs
465 struct elf_i386_dyn_relocs
*next
;
467 /* The input section of the reloc. */
470 /* Total number of relocs copied for the input section. */
473 /* Number of pc-relative relocs copied for the input section. */
474 bfd_size_type pc_count
;
477 /* i386 ELF linker hash entry. */
479 struct elf_i386_link_hash_entry
481 struct elf_link_hash_entry elf
;
483 /* Track dynamic relocs copied for this symbol. */
484 struct elf_i386_dyn_relocs
*dyn_relocs
;
487 /* i386 ELF linker hash table. */
489 struct elf_i386_link_hash_table
491 struct elf_link_hash_table elf
;
493 /* Short-cuts to get to dynamic linker sections. */
503 /* Get the i386 ELF linker hash table from a link_info structure. */
505 #define elf_i386_hash_table(p) \
506 ((struct elf_i386_link_hash_table *) ((p)->hash))
508 /* Create an entry in an i386 ELF linker hash table. */
510 static struct bfd_hash_entry
*
511 link_hash_newfunc (entry
, table
, string
)
512 struct bfd_hash_entry
*entry
;
513 struct bfd_hash_table
*table
;
516 /* Allocate the structure if it has not already been allocated by a
520 entry
= bfd_hash_allocate (table
,
521 sizeof (struct elf_i386_link_hash_entry
));
526 /* Call the allocation method of the superclass. */
527 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
530 struct elf_i386_link_hash_entry
*eh
;
532 eh
= (struct elf_i386_link_hash_entry
*) entry
;
533 eh
->dyn_relocs
= NULL
;
539 /* Create an i386 ELF linker hash table. */
541 static struct bfd_link_hash_table
*
542 elf_i386_link_hash_table_create (abfd
)
545 struct elf_i386_link_hash_table
*ret
;
546 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
548 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
552 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
554 bfd_release (abfd
, ret
);
566 return &ret
->elf
.root
;
569 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
570 shortcuts to them in our hash table. */
573 create_got_section (dynobj
, info
)
575 struct bfd_link_info
*info
;
577 struct elf_i386_link_hash_table
*htab
;
579 if (! _bfd_elf_create_got_section (dynobj
, info
))
582 htab
= elf_i386_hash_table (info
);
583 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
584 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
585 if (!htab
->sgot
|| !htab
->sgotplt
)
588 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
589 if (htab
->srelgot
== NULL
590 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
591 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
592 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
594 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
599 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
600 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
604 elf_i386_create_dynamic_sections (dynobj
, info
)
606 struct bfd_link_info
*info
;
608 struct elf_i386_link_hash_table
*htab
;
610 htab
= elf_i386_hash_table (info
);
611 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
614 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
617 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
618 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
619 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
621 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
623 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
624 || (!info
->shared
&& !htab
->srelbss
))
630 /* Copy the extra info we tack onto an elf_link_hash_entry. */
633 elf_i386_copy_indirect_symbol (dir
, ind
)
634 struct elf_link_hash_entry
*dir
, *ind
;
636 struct elf_i386_link_hash_entry
*edir
, *eind
;
638 edir
= (struct elf_i386_link_hash_entry
*) dir
;
639 eind
= (struct elf_i386_link_hash_entry
*) ind
;
641 if (edir
->dyn_relocs
== NULL
)
643 edir
->dyn_relocs
= eind
->dyn_relocs
;
644 eind
->dyn_relocs
= NULL
;
646 else if (eind
->dyn_relocs
!= NULL
)
649 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
652 /* Look through the relocs for a section during the first phase, and
653 allocate space in the global offset table or procedure linkage
657 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
659 struct bfd_link_info
*info
;
661 const Elf_Internal_Rela
*relocs
;
663 struct elf_i386_link_hash_table
*htab
;
665 Elf_Internal_Shdr
*symtab_hdr
;
666 struct elf_link_hash_entry
**sym_hashes
;
667 bfd_signed_vma
*local_got_refcounts
;
668 const Elf_Internal_Rela
*rel
;
669 const Elf_Internal_Rela
*rel_end
;
672 if (info
->relocateable
)
675 htab
= elf_i386_hash_table (info
);
676 dynobj
= htab
->elf
.dynobj
;
677 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
678 sym_hashes
= elf_sym_hashes (abfd
);
679 local_got_refcounts
= elf_local_got_refcounts (abfd
);
683 rel_end
= relocs
+ sec
->reloc_count
;
684 for (rel
= relocs
; rel
< rel_end
; rel
++)
686 unsigned long r_symndx
;
687 struct elf_link_hash_entry
*h
;
689 r_symndx
= ELF32_R_SYM (rel
->r_info
);
691 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
693 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
694 bfd_archive_filename (abfd
),
699 if (r_symndx
< symtab_hdr
->sh_info
)
702 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
704 /* Some relocs require a global offset table. */
705 if (htab
->sgot
== NULL
)
707 switch (ELF32_R_TYPE (rel
->r_info
))
713 htab
->elf
.dynobj
= dynobj
= abfd
;
714 if (!create_got_section (dynobj
, info
))
723 switch (ELF32_R_TYPE (rel
->r_info
))
726 /* This symbol requires a global offset table entry. */
729 if (h
->got
.refcount
== -1)
732 h
->got
.refcount
+= 1;
736 /* This is a global offset table entry for a local symbol. */
737 if (local_got_refcounts
== NULL
)
741 size
= symtab_hdr
->sh_info
;
742 size
*= sizeof (bfd_signed_vma
);
743 local_got_refcounts
= ((bfd_signed_vma
*)
744 bfd_zalloc (abfd
, size
));
745 if (local_got_refcounts
== NULL
)
747 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
749 local_got_refcounts
[r_symndx
] += 1;
754 /* This symbol requires a procedure linkage table entry. We
755 actually build the entry in adjust_dynamic_symbol,
756 because this might be a case of linking PIC code which is
757 never referenced by a dynamic object, in which case we
758 don't need to generate a procedure linkage table entry
761 /* If this is a local symbol, we resolve it directly without
762 creating a procedure linkage table entry. */
766 if (h
->plt
.refcount
== -1)
768 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
772 h
->plt
.refcount
+= 1;
777 if (h
!= NULL
&& !info
->shared
)
779 /* If this reloc is in a read-only section, we might
780 need a copy reloc. We can't check reliably at this
781 stage whether the section is read-only, as input
782 sections have not yet been mapped to output sections.
783 Tentatively set the flag for now, and correct in
784 adjust_dynamic_symbol. */
785 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
787 /* We may need a .plt entry if the function this reloc
788 refers to is in a shared lib. */
789 if (h
->plt
.refcount
== -1)
792 h
->plt
.refcount
+= 1;
795 /* If we are creating a shared library, and this is a reloc
796 against a global symbol, or a non PC relative reloc
797 against a local symbol, then we need to copy the reloc
798 into the shared library. However, if we are linking with
799 -Bsymbolic, we do not need to copy a reloc against a
800 global symbol which is defined in an object we are
801 including in the link (i.e., DEF_REGULAR is set). At
802 this point we have not seen all the input files, so it is
803 possible that DEF_REGULAR is not set now but will be set
804 later (it is never cleared). In case of a weak definition,
805 DEF_REGULAR may be cleared later by a strong definition in
806 a shared library. We account for that possibility below by
807 storing information in the relocs_copied field of the hash
808 table entry. A similar situation occurs when creating
809 shared libraries and symbol visibility changes render the
812 If on the other hand, we are creating an executable, we
813 may need to keep relocations for symbols satisfied by a
814 dynamic library if we manage to avoid copy relocs for the
817 && (sec
->flags
& SEC_ALLOC
) != 0
818 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
821 || h
->root
.type
== bfd_link_hash_defweak
822 || (h
->elf_link_hash_flags
823 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
825 && (sec
->flags
& SEC_ALLOC
) != 0
827 && (h
->root
.type
== bfd_link_hash_defweak
828 || (h
->elf_link_hash_flags
829 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
831 /* We must copy these reloc types into the output file.
832 Create a reloc section in dynobj and make room for
835 htab
->elf
.dynobj
= dynobj
= abfd
;
841 name
= (bfd_elf_string_from_elf_section
843 elf_elfheader (abfd
)->e_shstrndx
,
844 elf_section_data (sec
)->rel_hdr
.sh_name
));
848 if (strncmp (name
, ".rel", 4) != 0
849 || strcmp (bfd_get_section_name (abfd
, sec
),
852 (*_bfd_error_handler
)
853 (_("%s: bad relocation section name `%s\'"),
854 bfd_archive_filename (abfd
), name
);
857 sreloc
= bfd_get_section_by_name (dynobj
, name
);
862 sreloc
= bfd_make_section (dynobj
, name
);
863 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
864 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
865 if ((sec
->flags
& SEC_ALLOC
) != 0)
866 flags
|= SEC_ALLOC
| SEC_LOAD
;
868 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
869 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
872 elf_section_data (sec
)->sreloc
= sreloc
;
875 /* If this is a global symbol, we count the number of
876 relocations we need for this symbol. */
879 struct elf_i386_link_hash_entry
*eh
;
880 struct elf_i386_dyn_relocs
*p
;
882 eh
= (struct elf_i386_link_hash_entry
*) h
;
885 if (p
== NULL
|| p
->sec
!= sec
)
887 p
= ((struct elf_i386_dyn_relocs
*)
888 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
891 p
->next
= eh
->dyn_relocs
;
899 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
904 /* Track dynamic relocs needed for local syms too. */
905 elf_section_data (sec
)->local_dynrel
+= 1;
911 /* This relocation describes the C++ object vtable hierarchy.
912 Reconstruct it for later use during GC. */
913 case R_386_GNU_VTINHERIT
:
914 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
918 /* This relocation describes which C++ vtable entries are actually
919 used. Record for later use during GC. */
920 case R_386_GNU_VTENTRY
:
921 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
933 /* Return the section that should be marked against GC for a given
937 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
939 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
940 Elf_Internal_Rela
*rel
;
941 struct elf_link_hash_entry
*h
;
942 Elf_Internal_Sym
*sym
;
946 switch (ELF32_R_TYPE (rel
->r_info
))
948 case R_386_GNU_VTINHERIT
:
949 case R_386_GNU_VTENTRY
:
953 switch (h
->root
.type
)
955 case bfd_link_hash_defined
:
956 case bfd_link_hash_defweak
:
957 return h
->root
.u
.def
.section
;
959 case bfd_link_hash_common
:
960 return h
->root
.u
.c
.p
->section
;
969 if (!(elf_bad_symtab (abfd
)
970 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
971 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
972 && sym
->st_shndx
!= SHN_COMMON
))
974 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
981 /* Update the got entry reference counts for the section being removed. */
984 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
986 struct bfd_link_info
*info
;
988 const Elf_Internal_Rela
*relocs
;
990 Elf_Internal_Shdr
*symtab_hdr
;
991 struct elf_link_hash_entry
**sym_hashes
;
992 bfd_signed_vma
*local_got_refcounts
;
993 const Elf_Internal_Rela
*rel
, *relend
;
994 unsigned long r_symndx
;
995 struct elf_link_hash_entry
*h
;
998 elf_section_data (sec
)->local_dynrel
= 0;
1000 dynobj
= elf_hash_table (info
)->dynobj
;
1004 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1005 sym_hashes
= elf_sym_hashes (abfd
);
1006 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1008 relend
= relocs
+ sec
->reloc_count
;
1009 for (rel
= relocs
; rel
< relend
; rel
++)
1010 switch (ELF32_R_TYPE (rel
->r_info
))
1015 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1016 if (r_symndx
>= symtab_hdr
->sh_info
)
1018 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1019 if (h
->got
.refcount
> 0)
1020 h
->got
.refcount
-= 1;
1022 else if (local_got_refcounts
!= NULL
)
1024 if (local_got_refcounts
[r_symndx
] > 0)
1025 local_got_refcounts
[r_symndx
] -= 1;
1031 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1032 if (r_symndx
>= symtab_hdr
->sh_info
)
1034 struct elf_i386_link_hash_entry
*eh
;
1035 struct elf_i386_dyn_relocs
**pp
;
1036 struct elf_i386_dyn_relocs
*p
;
1038 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1040 if (!info
->shared
&& h
->plt
.refcount
> 0)
1041 h
->plt
.refcount
-= 1;
1043 eh
= (struct elf_i386_link_hash_entry
*) h
;
1045 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1048 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
1059 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1060 if (r_symndx
>= symtab_hdr
->sh_info
)
1062 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1063 if (h
->plt
.refcount
> 0)
1064 h
->plt
.refcount
-= 1;
1075 /* Adjust a symbol defined by a dynamic object and referenced by a
1076 regular object. The current definition is in some section of the
1077 dynamic object, but we're not including those sections. We have to
1078 change the definition to something the rest of the link can
1082 elf_i386_adjust_dynamic_symbol (info
, h
)
1083 struct bfd_link_info
*info
;
1084 struct elf_link_hash_entry
*h
;
1086 struct elf_i386_link_hash_table
*htab
;
1088 struct elf_i386_link_hash_entry
* eh
;
1089 struct elf_i386_dyn_relocs
*p
;
1091 unsigned int power_of_two
;
1093 htab
= elf_i386_hash_table (info
);
1094 dynobj
= htab
->elf
.dynobj
;
1096 /* If this is a function, put it in the procedure linkage table. We
1097 will fill in the contents of the procedure linkage table later,
1098 when we know the address of the .got section. */
1099 if (h
->type
== STT_FUNC
1100 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1102 if (h
->plt
.refcount
<= 0
1104 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1105 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
1107 /* This case can occur if we saw a PLT32 reloc in an input
1108 file, but the symbol was never referred to by a dynamic
1109 object, or if all references were garbage collected. In
1110 such a case, we don't actually need to build a procedure
1111 linkage table, and we can just do a PC32 reloc instead. */
1112 h
->plt
.refcount
= (bfd_vma
) -1;
1113 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1119 /* It's possible that we incorrectly decided a .plt reloc was
1120 needed for an R_386_PC32 reloc to a non-function sym in
1121 check_relocs. We can't decide accurately between function and
1122 non-function syms in check-relocs; Objects loaded later in
1123 the link may change h->type. So fix it now. */
1124 h
->plt
.refcount
= (bfd_vma
) -1;
1126 /* If this is a weak symbol, and there is a real definition, the
1127 processor independent code will have arranged for us to see the
1128 real definition first, and we can just use the same value. */
1129 if (h
->weakdef
!= NULL
)
1131 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1132 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1133 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1134 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1137 /* This is a reference to a symbol defined by a dynamic object which
1138 is not a function. */
1140 /* If we are creating a shared library, we must presume that the
1141 only references to the symbol are via the global offset table.
1142 For such cases we need not do anything here; the relocations will
1143 be handled correctly by relocate_section. */
1147 /* If there are no references to this symbol that do not use the
1148 GOT, we don't need to generate a copy reloc. */
1149 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1152 eh
= (struct elf_i386_link_hash_entry
*) h
;
1153 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1155 s
= p
->sec
->output_section
;
1156 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1160 /* If we didn't find any dynamic relocs in read-only sections, then
1161 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1164 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1168 /* We must allocate the symbol in our .dynbss section, which will
1169 become part of the .bss section of the executable. There will be
1170 an entry for this symbol in the .dynsym section. The dynamic
1171 object will contain position independent code, so all references
1172 from the dynamic object to this symbol will go through the global
1173 offset table. The dynamic linker will use the .dynsym entry to
1174 determine the address it must put in the global offset table, so
1175 both the dynamic object and the regular object will refer to the
1176 same memory location for the variable. */
1182 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1183 copy the initial value out of the dynamic object and into the
1184 runtime process image. We need to remember the offset into the
1185 .rel.bss section we are going to use. */
1186 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1190 srel
= htab
->srelbss
;
1193 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1194 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1197 /* We need to figure out the alignment required for this symbol. I
1198 have no idea how ELF linkers handle this. */
1199 power_of_two
= bfd_log2 (h
->size
);
1200 if (power_of_two
> 3)
1203 /* Apply the required alignment. */
1204 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1205 (bfd_size_type
) (1 << power_of_two
));
1206 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1208 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1212 /* Define the symbol as being at this point in the section. */
1213 h
->root
.u
.def
.section
= s
;
1214 h
->root
.u
.def
.value
= s
->_raw_size
;
1216 /* Increment the section size to make room for the symbol. */
1217 s
->_raw_size
+= h
->size
;
1222 /* This is the condition under which elf_i386_finish_dynamic_symbol
1223 will be called from elflink.h. If elflink.h doesn't call our
1224 finish_dynamic_symbol routine, we'll need to do something about
1225 initializing any .plt and .got entries in elf_i386_relocate_section. */
1226 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1228 && ((INFO)->shared \
1229 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1230 && ((H)->dynindx != -1 \
1231 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1233 /* Allocate space in .plt, .got and associated reloc sections for
1237 allocate_dynrelocs (h
, inf
)
1238 struct elf_link_hash_entry
*h
;
1241 struct bfd_link_info
*info
;
1242 struct elf_i386_link_hash_table
*htab
;
1244 struct elf_i386_link_hash_entry
*eh
;
1245 struct elf_i386_dyn_relocs
*p
;
1247 if (h
->root
.type
== bfd_link_hash_indirect
1248 || h
->root
.type
== bfd_link_hash_warning
)
1251 info
= (struct bfd_link_info
*) inf
;
1252 htab
= elf_i386_hash_table (info
);
1254 if (htab
->elf
.dynamic_sections_created
1255 && h
->plt
.refcount
> 0)
1257 /* Make sure this symbol is output as a dynamic symbol.
1258 Undefined weak syms won't yet be marked as dynamic. */
1259 if (h
->dynindx
== -1
1260 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1262 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1266 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1272 /* If this is the first .plt entry, make room for the special
1274 if (s
->_raw_size
== 0)
1275 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1277 h
->plt
.offset
= s
->_raw_size
;
1279 /* If this symbol is not defined in a regular file, and we are
1280 not generating a shared library, then set the symbol to this
1281 location in the .plt. This is required to make function
1282 pointers compare as equal between the normal executable and
1283 the shared library. */
1285 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1287 h
->root
.u
.def
.section
= s
;
1288 h
->root
.u
.def
.value
= h
->plt
.offset
;
1291 /* Make room for this entry. */
1292 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1294 /* We also need to make an entry in the .got.plt section, which
1295 will be placed in the .got section by the linker script. */
1301 /* We also need to make an entry in the .rel.plt section. */
1305 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1309 h
->plt
.offset
= (bfd_vma
) -1;
1310 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1315 h
->plt
.offset
= (bfd_vma
) -1;
1316 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1319 if (h
->got
.refcount
> 0)
1323 /* Make sure this symbol is output as a dynamic symbol.
1324 Undefined weak syms won't yet be marked as dynamic. */
1325 if (h
->dynindx
== -1
1326 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1328 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1333 h
->got
.offset
= s
->_raw_size
;
1335 dyn
= htab
->elf
.dynamic_sections_created
;
1336 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1337 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1340 h
->got
.offset
= (bfd_vma
) -1;
1342 eh
= (struct elf_i386_link_hash_entry
*) h
;
1343 if (eh
->dyn_relocs
== NULL
)
1346 /* In the shared -Bsymbolic case, discard space allocated for
1347 dynamic pc-relative relocs against symbols which turn out to be
1348 defined in regular objects. For the normal shared case, discard
1349 space for relocs that have become local due to symbol visibility
1354 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1355 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1358 struct elf_i386_dyn_relocs
**pp
;
1360 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1362 p
->count
-= p
->pc_count
;
1373 /* For the non-shared case, discard space for relocs against
1374 symbols which turn out to need copy relocs or are not
1377 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1378 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1379 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1380 || (htab
->elf
.dynamic_sections_created
1381 && (h
->root
.type
== bfd_link_hash_undefweak
1382 || h
->root
.type
== bfd_link_hash_undefined
))))
1384 /* Make sure this symbol is output as a dynamic symbol.
1385 Undefined weak syms won't yet be marked as dynamic. */
1386 if (h
->dynindx
== -1
1387 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1389 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1393 /* If that succeeded, we know we'll be keeping all the
1395 if (h
->dynindx
!= -1)
1399 eh
->dyn_relocs
= NULL
;
1404 /* Finally, allocate space. */
1405 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1407 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1408 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1414 /* Find any dynamic relocs that apply to read-only sections. */
1417 readonly_dynrelocs (h
, inf
)
1418 struct elf_link_hash_entry
*h
;
1421 struct elf_i386_link_hash_entry
*eh
;
1422 struct elf_i386_dyn_relocs
*p
;
1424 eh
= (struct elf_i386_link_hash_entry
*) h
;
1425 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1427 asection
*s
= p
->sec
->output_section
;
1429 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1431 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1433 info
->flags
|= DF_TEXTREL
;
1435 /* Not an error, just cut short the traversal. */
1442 /* Set the sizes of the dynamic sections. */
1445 elf_i386_size_dynamic_sections (output_bfd
, info
)
1446 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1447 struct bfd_link_info
*info
;
1449 struct elf_i386_link_hash_table
*htab
;
1455 htab
= elf_i386_hash_table (info
);
1456 dynobj
= htab
->elf
.dynobj
;
1460 if (htab
->elf
.dynamic_sections_created
)
1462 /* Set the contents of the .interp section to the interpreter. */
1465 s
= bfd_get_section_by_name (dynobj
, ".interp");
1468 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1469 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1473 /* Set up .got offsets for local syms, and space for local dynamic
1475 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1477 bfd_signed_vma
*local_got
;
1478 bfd_signed_vma
*end_local_got
;
1479 bfd_size_type locsymcount
;
1480 Elf_Internal_Shdr
*symtab_hdr
;
1483 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1486 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1488 bfd_size_type count
= elf_section_data (s
)->local_dynrel
;
1492 srel
= elf_section_data (s
)->sreloc
;
1493 srel
->_raw_size
+= count
* sizeof (Elf32_External_Rel
);
1497 local_got
= elf_local_got_refcounts (ibfd
);
1501 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1502 locsymcount
= symtab_hdr
->sh_info
;
1503 end_local_got
= local_got
+ locsymcount
;
1505 srel
= htab
->srelgot
;
1506 for (; local_got
< end_local_got
; ++local_got
)
1510 *local_got
= s
->_raw_size
;
1513 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1516 *local_got
= (bfd_vma
) -1;
1520 /* Allocate global sym .plt and .got entries, and space for global
1521 sym dynamic relocs. */
1522 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1524 /* We now have determined the sizes of the various dynamic sections.
1525 Allocate memory for them. */
1527 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1529 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1534 || s
== htab
->sgotplt
)
1536 /* Strip this section if we don't need it; see the
1539 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1541 if (s
->_raw_size
== 0)
1543 /* If we don't need this section, strip it from the
1544 output file. This is mostly to handle .rel.bss and
1545 .rel.plt. We must create both sections in
1546 create_dynamic_sections, because they must be created
1547 before the linker maps input sections to output
1548 sections. The linker does that before
1549 adjust_dynamic_symbol is called, and it is that
1550 function which decides whether anything needs to go
1551 into these sections. */
1555 if (s
!= htab
->srelplt
)
1558 /* We use the reloc_count field as a counter if we need
1559 to copy relocs into the output file. */
1565 /* It's not one of our sections, so don't allocate space. */
1569 if (s
->_raw_size
== 0)
1571 _bfd_strip_section_from_output (info
, s
);
1575 /* Allocate memory for the section contents. We use bfd_zalloc
1576 here in case unused entries are not reclaimed before the
1577 section's contents are written out. This should not happen,
1578 but this way if it does, we get a R_386_NONE reloc instead
1580 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1581 if (s
->contents
== NULL
)
1585 if (htab
->elf
.dynamic_sections_created
)
1587 /* Add some entries to the .dynamic section. We fill in the
1588 values later, in elf_i386_finish_dynamic_sections, but we
1589 must add the entries now so that we get the correct size for
1590 the .dynamic section. The DT_DEBUG entry is filled in by the
1591 dynamic linker and used by the debugger. */
1592 #define add_dynamic_entry(TAG, VAL) \
1593 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1597 if (!add_dynamic_entry (DT_DEBUG
, 0))
1601 if (htab
->splt
->_raw_size
!= 0)
1603 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1604 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1605 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1606 || !add_dynamic_entry (DT_JMPREL
, 0))
1612 if (!add_dynamic_entry (DT_REL
, 0)
1613 || !add_dynamic_entry (DT_RELSZ
, 0)
1614 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1617 /* If any dynamic relocs apply to a read-only section,
1618 then we need a DT_TEXTREL entry. */
1619 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
1621 if ((info
->flags
& DF_TEXTREL
) != 0)
1623 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1628 #undef add_dynamic_entry
1633 /* Set the correct type for an x86 ELF section. We do this by the
1634 section name, which is a hack, but ought to work. */
1637 elf_i386_fake_sections (abfd
, hdr
, sec
)
1638 bfd
*abfd ATTRIBUTE_UNUSED
;
1639 Elf32_Internal_Shdr
*hdr
;
1642 register const char *name
;
1644 name
= bfd_get_section_name (abfd
, sec
);
1646 /* This is an ugly, but unfortunately necessary hack that is
1647 needed when producing EFI binaries on x86. It tells
1648 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1649 containing ELF relocation info. We need this hack in order to
1650 be able to generate ELF binaries that can be translated into
1651 EFI applications (which are essentially COFF objects). Those
1652 files contain a COFF ".reloc" section inside an ELFNN object,
1653 which would normally cause BFD to segfault because it would
1654 attempt to interpret this section as containing relocation
1655 entries for section "oc". With this hack enabled, ".reloc"
1656 will be treated as a normal data section, which will avoid the
1657 segfault. However, you won't be able to create an ELFNN binary
1658 with a section named "oc" that needs relocations, but that's
1659 the kind of ugly side-effects you get when detecting section
1660 types based on their names... In practice, this limitation is
1661 unlikely to bite. */
1662 if (strcmp (name
, ".reloc") == 0)
1663 hdr
->sh_type
= SHT_PROGBITS
;
1668 /* Relocate an i386 ELF section. */
1671 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1672 contents
, relocs
, local_syms
, local_sections
)
1674 struct bfd_link_info
*info
;
1676 asection
*input_section
;
1678 Elf_Internal_Rela
*relocs
;
1679 Elf_Internal_Sym
*local_syms
;
1680 asection
**local_sections
;
1682 struct elf_i386_link_hash_table
*htab
;
1684 Elf_Internal_Shdr
*symtab_hdr
;
1685 struct elf_link_hash_entry
**sym_hashes
;
1686 bfd_vma
*local_got_offsets
;
1687 Elf_Internal_Rela
*rel
;
1688 Elf_Internal_Rela
*relend
;
1690 htab
= elf_i386_hash_table (info
);
1691 dynobj
= htab
->elf
.dynobj
;
1692 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1693 sym_hashes
= elf_sym_hashes (input_bfd
);
1694 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1697 relend
= relocs
+ input_section
->reloc_count
;
1698 for (; rel
< relend
; rel
++)
1701 reloc_howto_type
*howto
;
1702 unsigned long r_symndx
;
1703 struct elf_link_hash_entry
*h
;
1704 Elf_Internal_Sym
*sym
;
1708 boolean unresolved_reloc
;
1709 bfd_reloc_status_type r
;
1712 r_type
= ELF32_R_TYPE (rel
->r_info
);
1713 if (r_type
== (int) R_386_GNU_VTINHERIT
1714 || r_type
== (int) R_386_GNU_VTENTRY
)
1717 if ((indx
= (unsigned) r_type
) >= R_386_standard
1718 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1719 >= R_386_ext
- R_386_standard
))
1721 bfd_set_error (bfd_error_bad_value
);
1724 howto
= elf_howto_table
+ indx
;
1726 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1728 if (info
->relocateable
)
1730 /* This is a relocateable link. We don't have to change
1731 anything, unless the reloc is against a section symbol,
1732 in which case we have to adjust according to where the
1733 section symbol winds up in the output section. */
1734 if (r_symndx
< symtab_hdr
->sh_info
)
1736 sym
= local_syms
+ r_symndx
;
1737 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1741 sec
= local_sections
[r_symndx
];
1742 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1743 val
+= sec
->output_offset
+ sym
->st_value
;
1744 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1751 /* This is a final link. */
1755 unresolved_reloc
= false;
1756 if (r_symndx
< symtab_hdr
->sh_info
)
1758 sym
= local_syms
+ r_symndx
;
1759 sec
= local_sections
[r_symndx
];
1760 relocation
= (sec
->output_section
->vma
1761 + sec
->output_offset
1766 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1767 while (h
->root
.type
== bfd_link_hash_indirect
1768 || h
->root
.type
== bfd_link_hash_warning
)
1769 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1772 if (h
->root
.type
== bfd_link_hash_defined
1773 || h
->root
.type
== bfd_link_hash_defweak
)
1775 sec
= h
->root
.u
.def
.section
;
1776 if (sec
->output_section
== NULL
)
1777 /* Set a flag that will be cleared later if we find a
1778 relocation value for this symbol. output_section
1779 is typically NULL for symbols satisfied by a shared
1781 unresolved_reloc
= true;
1783 relocation
= (h
->root
.u
.def
.value
1784 + sec
->output_section
->vma
1785 + sec
->output_offset
);
1787 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1789 else if (info
->shared
1790 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1791 && !info
->no_undefined
1792 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1796 if (! ((*info
->callbacks
->undefined_symbol
)
1797 (info
, h
->root
.root
.string
, input_bfd
,
1798 input_section
, rel
->r_offset
,
1799 (!info
->shared
|| info
->no_undefined
1800 || ELF_ST_VISIBILITY (h
->other
)))))
1808 /* Relocation is to the entry for this symbol in the global
1810 if (htab
->sgot
== NULL
)
1817 off
= h
->got
.offset
;
1818 dyn
= htab
->elf
.dynamic_sections_created
;
1819 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1823 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1824 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1826 /* This is actually a static link, or it is a
1827 -Bsymbolic link and the symbol is defined
1828 locally, or the symbol was forced to be local
1829 because of a version file. We must initialize
1830 this entry in the global offset table. Since the
1831 offset must always be a multiple of 4, we use the
1832 least significant bit to record whether we have
1833 initialized it already.
1835 When doing a dynamic link, we create a .rel.got
1836 relocation entry to initialize the value. This
1837 is done in the finish_dynamic_symbol routine. */
1842 bfd_put_32 (output_bfd
, relocation
,
1843 htab
->sgot
->contents
+ off
);
1848 unresolved_reloc
= false;
1852 if (local_got_offsets
== NULL
)
1855 off
= local_got_offsets
[r_symndx
];
1857 /* The offset must always be a multiple of 4. We use
1858 the least significant bit to record whether we have
1859 already generated the necessary reloc. */
1864 bfd_put_32 (output_bfd
, relocation
,
1865 htab
->sgot
->contents
+ off
);
1870 Elf_Internal_Rel outrel
;
1872 srelgot
= htab
->srelgot
;
1873 if (srelgot
== NULL
)
1876 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1877 + htab
->sgot
->output_offset
1879 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1880 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1881 (((Elf32_External_Rel
*)
1883 + srelgot
->reloc_count
));
1884 ++srelgot
->reloc_count
;
1887 local_got_offsets
[r_symndx
] |= 1;
1891 if (off
>= (bfd_vma
) -2)
1894 relocation
= htab
->sgot
->output_offset
+ off
;
1898 /* Relocation is relative to the start of the global offset
1901 /* Note that sgot->output_offset is not involved in this
1902 calculation. We always want the start of .got. If we
1903 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1904 permitted by the ABI, we might have to change this
1906 relocation
-= htab
->sgot
->output_section
->vma
;
1910 /* Use global offset table as symbol value. */
1911 relocation
= htab
->sgot
->output_section
->vma
;
1912 unresolved_reloc
= false;
1916 /* Relocation is to the entry for this symbol in the
1917 procedure linkage table. */
1919 /* Resolve a PLT32 reloc against a local symbol directly,
1920 without using the procedure linkage table. */
1924 if (h
->plt
.offset
== (bfd_vma
) -1
1925 || htab
->splt
== NULL
)
1927 /* We didn't make a PLT entry for this symbol. This
1928 happens when statically linking PIC code, or when
1929 using -Bsymbolic. */
1933 relocation
= (htab
->splt
->output_section
->vma
1934 + htab
->splt
->output_offset
1936 unresolved_reloc
= false;
1942 && (input_section
->flags
& SEC_ALLOC
) != 0
1943 && (r_type
!= R_386_PC32
1946 && (! info
->symbolic
1947 || (h
->elf_link_hash_flags
1948 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1950 && (input_section
->flags
& SEC_ALLOC
) != 0
1953 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1954 && (((h
->elf_link_hash_flags
1955 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1956 && (h
->elf_link_hash_flags
1957 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1958 || h
->root
.type
== bfd_link_hash_undefweak
1959 || h
->root
.type
== bfd_link_hash_undefined
)))
1961 Elf_Internal_Rel outrel
;
1962 boolean skip
, relocate
;
1964 Elf32_External_Rel
*loc
;
1966 /* When generating a shared object, these relocations
1967 are copied into the output file to be resolved at run
1972 if (elf_section_data (input_section
)->stab_info
== NULL
)
1973 outrel
.r_offset
= rel
->r_offset
;
1976 off
= (_bfd_stab_section_offset
1977 (output_bfd
, htab
->elf
.stab_info
, input_section
,
1978 &elf_section_data (input_section
)->stab_info
,
1980 if (off
== (bfd_vma
) -1)
1982 outrel
.r_offset
= off
;
1985 outrel
.r_offset
+= (input_section
->output_section
->vma
1986 + input_section
->output_offset
);
1990 memset (&outrel
, 0, sizeof outrel
);
1995 && (r_type
== R_386_PC32
1998 || (h
->elf_link_hash_flags
1999 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2003 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2007 /* This symbol is local, or marked to become local. */
2009 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2012 sreloc
= elf_section_data (input_section
)->sreloc
;
2016 loc
= ((Elf32_External_Rel
*) sreloc
->contents
2017 + sreloc
->reloc_count
);
2018 sreloc
->reloc_count
+= 1;
2019 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2021 /* If this reloc is against an external symbol, we do
2022 not want to fiddle with the addend. Otherwise, we
2023 need to include the symbol value so that it becomes
2024 an addend for the dynamic reloc. */
2035 /* FIXME: Why do we allow debugging sections to escape this error?
2036 More importantly, why do we not emit dynamic relocs for
2037 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2038 If we had emitted the dynamic reloc, we could remove the
2040 if (unresolved_reloc
2042 && (input_section
->flags
& SEC_DEBUGGING
) != 0
2043 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2044 (*_bfd_error_handler
)
2045 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2046 bfd_archive_filename (input_bfd
),
2047 bfd_get_section_name (input_bfd
, input_section
),
2048 (long) rel
->r_offset
,
2049 h
->root
.root
.string
);
2051 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2052 contents
, rel
->r_offset
,
2053 relocation
, (bfd_vma
) 0);
2060 case bfd_reloc_overflow
:
2065 name
= h
->root
.root
.string
;
2068 name
= bfd_elf_string_from_elf_section (input_bfd
,
2069 symtab_hdr
->sh_link
,
2074 name
= bfd_section_name (input_bfd
, sec
);
2076 if (! ((*info
->callbacks
->reloc_overflow
)
2077 (info
, name
, howto
->name
, (bfd_vma
) 0,
2078 input_bfd
, input_section
, rel
->r_offset
)))
2084 case bfd_reloc_outofrange
:
2093 /* Finish up dynamic symbol handling. We set the contents of various
2094 dynamic sections here. */
2097 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2099 struct bfd_link_info
*info
;
2100 struct elf_link_hash_entry
*h
;
2101 Elf_Internal_Sym
*sym
;
2103 struct elf_i386_link_hash_table
*htab
;
2106 htab
= elf_i386_hash_table (info
);
2107 dynobj
= htab
->elf
.dynobj
;
2109 if (h
->plt
.offset
!= (bfd_vma
) -1)
2113 Elf_Internal_Rel rel
;
2115 /* This symbol has an entry in the procedure linkage table. Set
2118 if (h
->dynindx
== -1
2119 || htab
->splt
== NULL
2120 || htab
->sgotplt
== NULL
2121 || htab
->srelplt
== NULL
)
2124 /* Get the index in the procedure linkage table which
2125 corresponds to this symbol. This is the index of this symbol
2126 in all the symbols for which we are making plt entries. The
2127 first entry in the procedure linkage table is reserved. */
2128 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2130 /* Get the offset into the .got table of the entry that
2131 corresponds to this function. Each .got entry is 4 bytes.
2132 The first three are reserved. */
2133 got_offset
= (plt_index
+ 3) * 4;
2135 /* Fill in the entry in the procedure linkage table. */
2138 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2140 bfd_put_32 (output_bfd
,
2141 (htab
->sgotplt
->output_section
->vma
2142 + htab
->sgotplt
->output_offset
2144 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2148 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2150 bfd_put_32 (output_bfd
, got_offset
,
2151 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2154 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2155 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2156 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2157 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2159 /* Fill in the entry in the global offset table. */
2160 bfd_put_32 (output_bfd
,
2161 (htab
->splt
->output_section
->vma
2162 + htab
->splt
->output_offset
2165 htab
->sgotplt
->contents
+ got_offset
);
2167 /* Fill in the entry in the .rel.plt section. */
2168 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2169 + htab
->sgotplt
->output_offset
2171 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2172 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2173 ((Elf32_External_Rel
*) htab
->srelplt
->contents
2176 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2178 /* Mark the symbol as undefined, rather than as defined in
2179 the .plt section. Leave the value alone. */
2180 sym
->st_shndx
= SHN_UNDEF
;
2184 if (h
->got
.offset
!= (bfd_vma
) -1)
2186 Elf_Internal_Rel rel
;
2188 /* This symbol has an entry in the global offset table. Set it
2191 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2194 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2195 + htab
->sgot
->output_offset
2196 + (h
->got
.offset
& ~(bfd_vma
) 1));
2198 /* If this is a static link, or it is a -Bsymbolic link and the
2199 symbol is defined locally or was forced to be local because
2200 of a version file, we just want to emit a RELATIVE reloc.
2201 The entry in the global offset table will already have been
2202 initialized in the relocate_section function. */
2206 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2207 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2209 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2210 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2214 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2215 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2216 htab
->sgot
->contents
+ h
->got
.offset
);
2217 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2220 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2221 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2222 + htab
->srelgot
->reloc_count
));
2223 ++htab
->srelgot
->reloc_count
;
2226 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2228 Elf_Internal_Rel rel
;
2230 /* This symbol needs a copy reloc. Set it up. */
2232 if (h
->dynindx
== -1
2233 || (h
->root
.type
!= bfd_link_hash_defined
2234 && h
->root
.type
!= bfd_link_hash_defweak
)
2235 || htab
->srelbss
== NULL
)
2238 rel
.r_offset
= (h
->root
.u
.def
.value
2239 + h
->root
.u
.def
.section
->output_section
->vma
2240 + h
->root
.u
.def
.section
->output_offset
);
2241 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2242 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2243 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2244 + htab
->srelbss
->reloc_count
));
2245 ++htab
->srelbss
->reloc_count
;
2248 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2249 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2250 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2251 sym
->st_shndx
= SHN_ABS
;
2256 /* Used to decide how to sort relocs in an optimal manner for the
2257 dynamic linker, before writing them out. */
2259 static enum elf_reloc_type_class
2260 elf_i386_reloc_type_class (rela
)
2261 const Elf_Internal_Rela
*rela
;
2263 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2265 case R_386_RELATIVE
:
2266 return reloc_class_relative
;
2267 case R_386_JUMP_SLOT
:
2268 return reloc_class_plt
;
2270 return reloc_class_copy
;
2272 return reloc_class_normal
;
2276 /* Finish up the dynamic sections. */
2279 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2281 struct bfd_link_info
*info
;
2283 struct elf_i386_link_hash_table
*htab
;
2287 htab
= elf_i386_hash_table (info
);
2288 dynobj
= htab
->elf
.dynobj
;
2289 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2291 if (htab
->elf
.dynamic_sections_created
)
2293 Elf32_External_Dyn
*dyncon
, *dynconend
;
2295 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2298 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2299 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2300 for (; dyncon
< dynconend
; dyncon
++)
2302 Elf_Internal_Dyn dyn
;
2304 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2312 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2313 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2317 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2318 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2322 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2323 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2325 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2326 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2330 /* My reading of the SVR4 ABI indicates that the
2331 procedure linkage table relocs (DT_JMPREL) should be
2332 included in the overall relocs (DT_REL). This is
2333 what Solaris does. However, UnixWare can not handle
2334 that case. Therefore, we override the DT_RELSZ entry
2335 here to make it not include the JMPREL relocs. Since
2336 the linker script arranges for .rel.plt to follow all
2337 other relocation sections, we don't have to worry
2338 about changing the DT_REL entry. */
2339 if (htab
->srelplt
!= NULL
)
2341 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2342 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2344 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2346 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2351 /* Fill in the first entry in the procedure linkage table. */
2352 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2355 memcpy (htab
->splt
->contents
,
2356 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2359 memcpy (htab
->splt
->contents
,
2360 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2361 bfd_put_32 (output_bfd
,
2362 (htab
->sgotplt
->output_section
->vma
2363 + htab
->sgotplt
->output_offset
2365 htab
->splt
->contents
+ 2);
2366 bfd_put_32 (output_bfd
,
2367 (htab
->sgotplt
->output_section
->vma
2368 + htab
->sgotplt
->output_offset
2370 htab
->splt
->contents
+ 8);
2373 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2374 really seem like the right value. */
2375 elf_section_data (htab
->splt
->output_section
)
2376 ->this_hdr
.sh_entsize
= 4;
2382 /* Fill in the first three entries in the global offset table. */
2383 if (htab
->sgotplt
->_raw_size
> 0)
2385 bfd_put_32 (output_bfd
,
2386 (sdyn
== NULL
? (bfd_vma
) 0
2387 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2388 htab
->sgotplt
->contents
);
2389 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2390 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2393 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2398 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2399 #define TARGET_LITTLE_NAME "elf32-i386"
2400 #define ELF_ARCH bfd_arch_i386
2401 #define ELF_MACHINE_CODE EM_386
2402 #define ELF_MAXPAGESIZE 0x1000
2404 #define elf_backend_can_gc_sections 1
2405 #define elf_backend_want_got_plt 1
2406 #define elf_backend_plt_readonly 1
2407 #define elf_backend_want_plt_sym 0
2408 #define elf_backend_got_header_size 12
2409 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2411 #define elf_info_to_howto elf_i386_info_to_howto
2412 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2414 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2415 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2416 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2418 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2419 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
2420 #define elf_backend_check_relocs elf_i386_check_relocs
2421 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2422 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2423 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2424 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2425 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2426 #define elf_backend_relocate_section elf_i386_relocate_section
2427 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2428 #define elf_backend_fake_sections elf_i386_fake_sections
2429 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2430 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2431 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2433 #include "elf32-target.h"