1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 static reloc_howto_type
*elf_i386_reloc_type_lookup
27 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
28 static void elf_i386_info_to_howto
29 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
30 static void elf_i386_info_to_howto_rel
31 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
32 static boolean elf_i386_check_relocs
33 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
34 const Elf_Internal_Rela
*));
35 static boolean elf_i386_adjust_dynamic_symbol
36 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
37 static boolean elf_i386_size_dynamic_sections
38 PARAMS ((bfd
*, struct bfd_link_info
*));
39 static boolean elf_i386_relocate_section
40 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
41 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
42 static boolean elf_i386_finish_dynamic_symbol
43 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
45 static boolean elf_i386_finish_dynamic_sections
46 PARAMS ((bfd
*, struct bfd_link_info
*));
48 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
67 static CONST
char *CONST reloc_type_names
[] =
83 static reloc_howto_type elf_howto_table
[]=
85 HOWTO(R_386_NONE
, 0,0, 0,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_NONE", true,0x00000000,0x00000000,false),
86 HOWTO(R_386_32
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_32", true,0xffffffff,0xffffffff,false),
87 HOWTO(R_386_PC32
, 0,2,32,true, 0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_PC32", true,0xffffffff,0xffffffff,true),
88 HOWTO(R_386_GOT32
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
89 HOWTO(R_386_PLT32
, 0,2,32,true,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
90 HOWTO(R_386_COPY
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_COPY", true,0xffffffff,0xffffffff,false),
91 HOWTO(R_386_GLOB_DAT
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false),
92 HOWTO(R_386_JUMP_SLOT
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false),
93 HOWTO(R_386_RELATIVE
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
94 HOWTO(R_386_GOTOFF
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
95 HOWTO(R_386_GOTPC
, 0,2,32,true,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
98 #ifdef DEBUG_GEN_RELOC
99 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
104 static reloc_howto_type
*
105 elf_i386_reloc_type_lookup (abfd
, code
)
107 bfd_reloc_code_real_type code
;
112 TRACE ("BFD_RELOC_NONE");
113 return &elf_howto_table
[ (int)R_386_NONE
];
116 TRACE ("BFD_RELOC_32");
117 return &elf_howto_table
[ (int)R_386_32
];
119 case BFD_RELOC_32_PCREL
:
120 TRACE ("BFD_RELOC_PC32");
121 return &elf_howto_table
[ (int)R_386_PC32
];
123 case BFD_RELOC_386_GOT32
:
124 TRACE ("BFD_RELOC_386_GOT32");
125 return &elf_howto_table
[ (int)R_386_GOT32
];
127 case BFD_RELOC_386_PLT32
:
128 TRACE ("BFD_RELOC_386_PLT32");
129 return &elf_howto_table
[ (int)R_386_PLT32
];
131 case BFD_RELOC_386_COPY
:
132 TRACE ("BFD_RELOC_386_COPY");
133 return &elf_howto_table
[ (int)R_386_COPY
];
135 case BFD_RELOC_386_GLOB_DAT
:
136 TRACE ("BFD_RELOC_386_GLOB_DAT");
137 return &elf_howto_table
[ (int)R_386_GLOB_DAT
];
139 case BFD_RELOC_386_JUMP_SLOT
:
140 TRACE ("BFD_RELOC_386_JUMP_SLOT");
141 return &elf_howto_table
[ (int)R_386_JUMP_SLOT
];
143 case BFD_RELOC_386_RELATIVE
:
144 TRACE ("BFD_RELOC_386_RELATIVE");
145 return &elf_howto_table
[ (int)R_386_RELATIVE
];
147 case BFD_RELOC_386_GOTOFF
:
148 TRACE ("BFD_RELOC_386_GOTOFF");
149 return &elf_howto_table
[ (int)R_386_GOTOFF
];
151 case BFD_RELOC_386_GOTPC
:
152 TRACE ("BFD_RELOC_386_GOTPC");
153 return &elf_howto_table
[ (int)R_386_GOTPC
];
164 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
167 Elf32_Internal_Rela
*dst
;
169 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_386_max
);
171 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
175 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
178 Elf32_Internal_Rel
*dst
;
180 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_386_max
);
182 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
185 /* Functions for the i386 ELF linker. */
187 /* The name of the dynamic interpreter. This is put in the .interp
190 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
192 /* The size in bytes of an entry in the procedure linkage table. */
194 #define PLT_ENTRY_SIZE 16
196 /* The first entry in an absolute procedure linkage table looks like
197 this. See the SVR4 ABI i386 supplement to see how this works. */
199 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
201 0xff, 0x35, /* pushl contents of address */
202 0, 0, 0, 0, /* replaced with address of .got + 4. */
203 0xff, 0x25, /* jmp indirect */
204 0, 0, 0, 0, /* replaced with address of .got + 8. */
205 0, 0, 0, 0 /* pad out to 16 bytes. */
208 /* Subsequent entries in an absolute procedure linkage table look like
211 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
213 0xff, 0x25, /* jmp indirect */
214 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
215 0x68, /* pushl immediate */
216 0, 0, 0, 0, /* replaced with offset into relocation table. */
217 0xe9, /* jmp relative */
218 0, 0, 0, 0 /* replaced with offset to start of .plt. */
221 /* The first entry in a PIC procedure linkage table look like this. */
223 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
225 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
226 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
227 0, 0, 0, 0 /* pad out to 16 bytes. */
230 /* Subsequent entries in a PIC procedure linkage table look like this. */
232 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
234 0xff, 0xa3, /* jmp *offset(%ebx) */
235 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
236 0x68, /* pushl immediate */
237 0, 0, 0, 0, /* replaced with offset into relocation table. */
238 0xe9, /* jmp relative */
239 0, 0, 0, 0 /* replaced with offset to start of .plt. */
242 /* Look through the relocs for a section during the first phase, and
243 allocate space in the global offset table or procedure linkage
247 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
249 struct bfd_link_info
*info
;
251 const Elf_Internal_Rela
*relocs
;
254 Elf_Internal_Shdr
*symtab_hdr
;
255 struct elf_link_hash_entry
**sym_hashes
;
256 bfd_vma
*local_got_offsets
;
257 const Elf_Internal_Rela
*rel
;
258 const Elf_Internal_Rela
*rel_end
;
263 if (info
->relocateable
)
266 dynobj
= elf_hash_table (info
)->dynobj
;
267 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
268 sym_hashes
= elf_sym_hashes (abfd
);
269 local_got_offsets
= elf_local_got_offsets (abfd
);
275 rel_end
= relocs
+ sec
->reloc_count
;
276 for (rel
= relocs
; rel
< rel_end
; rel
++)
279 struct elf_link_hash_entry
*h
;
281 r_symndx
= ELF32_R_SYM (rel
->r_info
);
283 if (r_symndx
< symtab_hdr
->sh_info
)
286 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
288 /* Some relocs require a global offset table. */
291 switch (ELF32_R_TYPE (rel
->r_info
))
296 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
297 if (! _bfd_elf_create_got_section (dynobj
, info
))
306 switch (ELF32_R_TYPE (rel
->r_info
))
309 /* This symbol requires a global offset table entry. */
313 sgot
= bfd_get_section_by_name (dynobj
, ".got");
314 BFD_ASSERT (sgot
!= NULL
);
318 && (h
!= NULL
|| info
->shared
))
320 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
323 srelgot
= bfd_make_section (dynobj
, ".rel.got");
325 || ! bfd_set_section_flags (dynobj
, srelgot
,
331 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
338 if (h
->got_offset
!= (bfd_vma
) -1)
340 /* We have already allocated space in the .got. */
343 h
->got_offset
= sgot
->_raw_size
;
345 /* Make sure this symbol is output as a dynamic symbol. */
346 if (h
->dynindx
== -1)
348 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
352 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
356 /* This is a global offset table entry for a local
358 if (local_got_offsets
== NULL
)
363 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
364 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
365 if (local_got_offsets
== NULL
)
367 bfd_set_error (bfd_error_no_memory
);
370 elf_local_got_offsets (abfd
) = local_got_offsets
;
371 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
372 local_got_offsets
[i
] = (bfd_vma
) -1;
374 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
376 /* We have already allocated space in the .got. */
379 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
383 /* If we are generating a shared object, we need to
384 output a R_386_RELATIVE reloc so that the dynamic
385 linker can adjust this GOT entry. */
386 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
390 sgot
->_raw_size
+= 4;
395 /* This symbol requires a procedure linkage table entry. We
396 actually build the entry in adjust_dynamic_symbol,
397 because this might be a case of linking PIC code without
398 linking in any dynamic objects, in which case we don't
399 need to generate a procedure linkage table after all. */
401 /* If this is a local symbol, we resolve it directly without
402 creating a procedure linkage table entry. */
406 /* Make sure this symbol is output as a dynamic symbol. */
407 if (h
->dynindx
== -1)
409 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
413 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
420 && (sec
->flags
& SEC_ALLOC
) != 0)
422 /* When creating a shared object, we must copy these
423 reloc types into the output file. We create a reloc
424 section in dynobj and make room for this reloc. */
429 name
= (bfd_elf_string_from_elf_section
431 elf_elfheader (abfd
)->e_shstrndx
,
432 elf_section_data (sec
)->rel_hdr
.sh_name
));
436 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
437 && strcmp (bfd_get_section_name (abfd
, sec
),
440 sreloc
= bfd_get_section_by_name (dynobj
, name
);
443 sreloc
= bfd_make_section (dynobj
, name
);
445 || ! bfd_set_section_flags (dynobj
, sreloc
,
451 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
456 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
469 /* Adjust a symbol defined by a dynamic object and referenced by a
470 regular object. The current definition is in some section of the
471 dynamic object, but we're not including those sections. We have to
472 change the definition to something the rest of the link can
476 elf_i386_adjust_dynamic_symbol (info
, h
)
477 struct bfd_link_info
*info
;
478 struct elf_link_hash_entry
*h
;
482 unsigned int power_of_two
;
484 dynobj
= elf_hash_table (info
)->dynobj
;
486 /* Make sure we know what is going on here. */
487 BFD_ASSERT (dynobj
!= NULL
488 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
489 || ((h
->elf_link_hash_flags
490 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
491 && (h
->elf_link_hash_flags
492 & ELF_LINK_HASH_REF_REGULAR
) != 0
493 && (h
->elf_link_hash_flags
494 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
496 /* If this is a function, put it in the procedure linkage table. We
497 will fill in the contents of the procedure linkage table later,
498 when we know the address of the .got section. */
499 if (h
->type
== STT_FUNC
500 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
502 if (! elf_hash_table (info
)->dynamic_sections_created
)
504 /* This case can occur if we saw a PLT32 reloc in an input
505 file, but none of the input files were dynamic objects.
506 In such a case, we don't actually need to build a
507 procedure linkage table, and we can just do a PC32 reloc
509 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
513 s
= bfd_get_section_by_name (dynobj
, ".plt");
514 BFD_ASSERT (s
!= NULL
);
516 /* If this is the first .plt entry, make room for the special
518 if (s
->_raw_size
== 0)
519 s
->_raw_size
+= PLT_ENTRY_SIZE
;
521 /* If this symbol is not defined in a regular file, and we are
522 not generating a shared library, then set the symbol to this
523 location in the .plt. This is required to make function
524 pointers compare as equal between the normal executable and
525 the shared library. */
527 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
529 h
->root
.u
.def
.section
= s
;
530 h
->root
.u
.def
.value
= s
->_raw_size
;
533 h
->plt_offset
= s
->_raw_size
;
535 /* Make room for this entry. */
536 s
->_raw_size
+= PLT_ENTRY_SIZE
;
538 /* We also need to make an entry in the .got.plt section, which
539 will be placed in the .got section by the linker script. */
541 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
542 BFD_ASSERT (s
!= NULL
);
545 /* We also need to make an entry in the .rel.plt section. */
547 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
548 BFD_ASSERT (s
!= NULL
);
549 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
554 /* If this is a weak symbol, and there is a real definition, the
555 processor independent code will have arranged for us to see the
556 real definition first, and we can just use the same value. */
557 if (h
->weakdef
!= NULL
)
559 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
560 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
561 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
562 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
566 /* This is a reference to a symbol defined by a dynamic object which
567 is not a function. */
569 /* If we are creating a shared library, we must presume that the
570 only references to the symbol are via the global offset table.
571 For such cases we need not do anything here; the relocations will
572 be handled correctly by relocate_section. */
576 /* We must allocate the symbol in our .dynbss section, which will
577 become part of the .bss section of the executable. There will be
578 an entry for this symbol in the .dynsym section. The dynamic
579 object will contain position independent code, so all references
580 from the dynamic object to this symbol will go through the global
581 offset table. The dynamic linker will use the .dynsym entry to
582 determine the address it must put in the global offset table, so
583 both the dynamic object and the regular object will refer to the
584 same memory location for the variable. */
586 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
587 BFD_ASSERT (s
!= NULL
);
589 /* If the symbol is currently defined in the .bss section of the
590 dynamic object, then it is OK to simply initialize it to zero.
591 If the symbol is in some other section, we must generate a
592 R_386_COPY reloc to tell the dynamic linker to copy the initial
593 value out of the dynamic object and into the runtime process
594 image. We need to remember the offset into the .rel.bss section
595 we are going to use. */
596 if ((h
->root
.u
.def
.section
->flags
& SEC_LOAD
) != 0)
600 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
601 BFD_ASSERT (srel
!= NULL
);
602 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
603 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
606 /* We need to figure out the alignment required for this symbol. I
607 have no idea how ELF linkers handle this. */
608 power_of_two
= bfd_log2 (h
->size
);
609 if (power_of_two
> 3)
612 /* Apply the required alignment. */
613 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
614 (bfd_size_type
) (1 << power_of_two
));
615 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
617 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
621 /* Define the symbol as being at this point in the section. */
622 h
->root
.u
.def
.section
= s
;
623 h
->root
.u
.def
.value
= s
->_raw_size
;
625 /* Increment the section size to make room for the symbol. */
626 s
->_raw_size
+= h
->size
;
631 /* Set the sizes of the dynamic sections. */
634 elf_i386_size_dynamic_sections (output_bfd
, info
)
636 struct bfd_link_info
*info
;
644 dynobj
= elf_hash_table (info
)->dynobj
;
645 BFD_ASSERT (dynobj
!= NULL
);
647 if (elf_hash_table (info
)->dynamic_sections_created
)
649 /* Set the contents of the .interp section to the interpreter. */
652 s
= bfd_get_section_by_name (dynobj
, ".interp");
653 BFD_ASSERT (s
!= NULL
);
654 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
655 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
660 /* We may have created entries in the .rel.got section.
661 However, if we are not creating the dynamic sections, we will
662 not actually use these entries. Reset the size of .rel.got,
663 which will cause it to get stripped from the output file
665 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
670 /* The check_relocs and adjust_dynamic_symbol entry points have
671 determined the sizes of the various dynamic sections. Allocate
676 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
681 if ((s
->flags
& SEC_IN_MEMORY
) == 0)
684 /* It's OK to base decisions on the section name, because none
685 of the dynobj section names depend upon the input files. */
686 name
= bfd_get_section_name (dynobj
, s
);
690 if (strcmp (name
, ".plt") == 0)
692 if (s
->_raw_size
== 0)
694 /* Strip this section if we don't need it; see the
700 /* Remember whether there is a PLT. */
704 else if (strncmp (name
, ".rel", 4) == 0)
706 if (s
->_raw_size
== 0)
708 /* If we don't need this section, strip it from the
709 output file. This is mostly to handle .rel.bss and
710 .rel.plt. We must create both sections in
711 create_dynamic_sections, because they must be created
712 before the linker maps input sections to output
713 sections. The linker does that before
714 adjust_dynamic_symbol is called, and it is that
715 function which decides whether anything needs to go
716 into these sections. */
723 /* Remember whether there are any reloc sections other
725 if (strcmp (name
, ".rel.plt") != 0)
728 /* If this relocation section applies to a read only
729 section, then we probably need a DT_TEXTREL entry. */
730 target
= bfd_get_section_by_name (output_bfd
, name
+ 4);
732 && (target
->flags
& SEC_READONLY
) != 0)
735 /* We use the reloc_count field as a counter if we need
736 to copy relocs into the output file. */
740 else if (strncmp (name
, ".got", 4) != 0)
742 /* It's not one of our sections, so don't allocate space. */
750 for (spp
= &s
->output_section
->owner
->sections
;
751 *spp
!= s
->output_section
;
754 *spp
= s
->output_section
->next
;
755 --s
->output_section
->owner
->section_count
;
760 /* Allocate memory for the section contents. */
761 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
762 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
764 bfd_set_error (bfd_error_no_memory
);
769 if (elf_hash_table (info
)->dynamic_sections_created
)
771 /* Add some entries to the .dynamic section. We fill in the
772 values later, in elf_i386_finish_dynamic_sections, but we
773 must add the entries now so that we get the correct size for
774 the .dynamic section. The DT_DEBUG entry is filled in by the
775 dynamic linker and used by the debugger. */
778 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
784 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
785 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
786 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
787 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
793 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
794 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
795 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
796 sizeof (Elf32_External_Rel
)))
802 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
810 /* Relocate an i386 ELF section. */
813 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
814 contents
, relocs
, local_syms
, local_sections
)
816 struct bfd_link_info
*info
;
818 asection
*input_section
;
820 Elf_Internal_Rela
*relocs
;
821 Elf_Internal_Sym
*local_syms
;
822 asection
**local_sections
;
825 Elf_Internal_Shdr
*symtab_hdr
;
826 struct elf_link_hash_entry
**sym_hashes
;
827 bfd_vma
*local_got_offsets
;
831 Elf_Internal_Rela
*rel
;
832 Elf_Internal_Rela
*relend
;
834 dynobj
= elf_hash_table (info
)->dynobj
;
835 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
836 sym_hashes
= elf_sym_hashes (input_bfd
);
837 local_got_offsets
= elf_local_got_offsets (input_bfd
);
844 relend
= relocs
+ input_section
->reloc_count
;
845 for (; rel
< relend
; rel
++)
848 reloc_howto_type
*howto
;
850 struct elf_link_hash_entry
*h
;
851 Elf_Internal_Sym
*sym
;
854 bfd_reloc_status_type r
;
857 r_type
= ELF32_R_TYPE (rel
->r_info
);
858 if (r_type
< 0 || r_type
>= (int) R_386_max
)
860 bfd_set_error (bfd_error_bad_value
);
863 howto
= elf_howto_table
+ r_type
;
865 r_symndx
= ELF32_R_SYM (rel
->r_info
);
867 if (info
->relocateable
)
869 /* This is a relocateable link. We don't have to change
870 anything, unless the reloc is against a section symbol,
871 in which case we have to adjust according to where the
872 section symbol winds up in the output section. */
873 if (r_symndx
< symtab_hdr
->sh_info
)
875 sym
= local_syms
+ r_symndx
;
876 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
880 sec
= local_sections
[r_symndx
];
881 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
882 val
+= sec
->output_offset
+ sym
->st_value
;
883 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
890 /* This is a final link. */
896 if (r_symndx
< symtab_hdr
->sh_info
)
898 sym
= local_syms
+ r_symndx
;
899 sec
= local_sections
[r_symndx
];
900 relocation
= (sec
->output_section
->vma
906 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
907 if (h
->root
.type
== bfd_link_hash_defined
908 || h
->root
.type
== bfd_link_hash_defweak
)
910 sec
= h
->root
.u
.def
.section
;
911 if (r_type
== R_386_GOTPC
912 || (r_type
== R_386_PLT32
913 && h
->plt_offset
!= (bfd_vma
) -1)
914 || (r_type
== R_386_GOT32
915 && elf_hash_table (info
)->dynamic_sections_created
)
917 && (r_type
== R_386_32
918 || r_type
== R_386_PC32
)
919 && (input_section
->flags
& SEC_ALLOC
) != 0))
921 /* In these cases, we don't need the relocation
922 value. We check specially because in some
923 obscure cases sec->output_section will be NULL. */
927 relocation
= (h
->root
.u
.def
.value
928 + sec
->output_section
->vma
929 + sec
->output_offset
);
931 else if (h
->root
.type
== bfd_link_hash_undefweak
)
933 else if (info
->shared
)
937 if (! ((*info
->callbacks
->undefined_symbol
)
938 (info
, h
->root
.root
.string
, input_bfd
,
939 input_section
, rel
->r_offset
)))
948 /* Relocation is to the entry for this symbol in the global
952 sgot
= bfd_get_section_by_name (dynobj
, ".got");
953 BFD_ASSERT (sgot
!= NULL
);
961 BFD_ASSERT (off
!= (bfd_vma
) -1);
963 if (! elf_hash_table (info
)->dynamic_sections_created
)
965 /* This is actually a static link. We must
966 initialize this entry in the global offset table.
967 Since the offset must always be a multiple of 4,
968 we use the least significant bit to record
969 whether we have initialized it already.
971 When doing a dynamic link, we create a .rel.got
972 relocation entry to initialize the value. This
973 is done in the finish_dynamic_symbol routine. */
978 bfd_put_32 (output_bfd
, relocation
,
979 sgot
->contents
+ off
);
984 relocation
= sgot
->output_offset
+ off
;
990 BFD_ASSERT (local_got_offsets
!= NULL
991 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
993 off
= local_got_offsets
[r_symndx
];
995 /* The offset must always be a multiple of 4. We use
996 the least significant bit to record whether we have
997 already generated the necessary reloc. */
1002 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1007 Elf_Internal_Rel outrel
;
1009 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1010 BFD_ASSERT (srelgot
!= NULL
);
1012 outrel
.r_offset
= (sgot
->output_section
->vma
1013 + sgot
->output_offset
1015 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1016 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1017 (((Elf32_External_Rel
*)
1019 + srelgot
->reloc_count
));
1020 ++srelgot
->reloc_count
;
1023 local_got_offsets
[r_symndx
] |= 1;
1026 relocation
= sgot
->output_offset
+ off
;
1032 /* Relocation is relative to the start of the global offset
1037 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1038 BFD_ASSERT (sgot
!= NULL
);
1041 /* Note that sgot->output_offset is not involved in this
1042 calculation. We always want the start of .got. If we
1043 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1044 permitted by the ABI, we might have to change this
1046 relocation
-= sgot
->output_section
->vma
;
1051 /* Use global offset table as symbol value. */
1055 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1056 BFD_ASSERT (sgot
!= NULL
);
1059 relocation
= sgot
->output_section
->vma
;
1064 /* Relocation is to the entry for this symbol in the
1065 procedure linkage table. */
1067 /* Resolve a PLT32 reloc again a local symbol directly,
1068 without using the procedure linkage table. */
1072 if (h
->plt_offset
== (bfd_vma
) -1)
1074 /* We didn't make a PLT entry for this symbol. This
1075 happens when statically linking PIC code. */
1081 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1082 BFD_ASSERT (splt
!= NULL
);
1085 relocation
= (splt
->output_section
->vma
1086 + splt
->output_offset
1094 && (input_section
->flags
& SEC_ALLOC
) != 0)
1096 Elf_Internal_Rel outrel
;
1098 /* When generating a shared object, these relocations
1099 are copied into the output file to be resolved at run
1104 shared_name
= (bfd_elf_string_from_elf_section
1106 elf_elfheader (input_bfd
)->e_shstrndx
,
1107 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1108 if (shared_name
== NULL
)
1111 BFD_ASSERT (strncmp (shared_name
, ".rel", 4) == 0
1112 && strcmp (bfd_get_section_name (input_bfd
,
1114 shared_name
+ 4) == 0);
1116 sreloc
= bfd_get_section_by_name (dynobj
, shared_name
);
1117 BFD_ASSERT (sreloc
!= NULL
);
1120 outrel
.r_offset
= (rel
->r_offset
1121 + input_section
->output_section
->vma
1122 + input_section
->output_offset
);
1123 if (r_type
== R_386_PC32
)
1127 if (! ((*info
->callbacks
->undefined_symbol
)
1128 (info
, shared_name
? shared_name
: sec
->name
, input_bfd
,
1129 input_section
, rel
->r_offset
)))
1130 bfd_set_error (bfd_error_bad_value
);
1134 BFD_ASSERT (h
->dynindx
!= -1);
1135 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_PC32
);
1141 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1144 BFD_ASSERT (h
->dynindx
!= (bfd_vma
) -1);
1145 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1149 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1150 (((Elf32_External_Rel
*)
1152 + sreloc
->reloc_count
));
1153 ++sreloc
->reloc_count
;
1155 /* If this reloc is against an external symbol, we do
1156 not want to fiddle with the addend. Otherwise, we
1157 need to include the symbol value so that it becomes
1158 an addend for the dynamic reloc. */
1169 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1170 contents
, rel
->r_offset
,
1171 relocation
, (bfd_vma
) 0);
1173 if (r
!= bfd_reloc_ok
)
1178 case bfd_reloc_outofrange
:
1180 case bfd_reloc_overflow
:
1185 name
= h
->root
.root
.string
;
1188 name
= bfd_elf_string_from_elf_section (input_bfd
,
1189 symtab_hdr
->sh_link
,
1194 name
= bfd_section_name (input_bfd
, sec
);
1196 if (! ((*info
->callbacks
->reloc_overflow
)
1197 (info
, name
, howto
->name
, (bfd_vma
) 0,
1198 input_bfd
, input_section
, rel
->r_offset
)))
1209 /* Finish up dynamic symbol handling. We set the contents of various
1210 dynamic sections here. */
1213 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1215 struct bfd_link_info
*info
;
1216 struct elf_link_hash_entry
*h
;
1217 Elf_Internal_Sym
*sym
;
1221 dynobj
= elf_hash_table (info
)->dynobj
;
1223 if (h
->plt_offset
!= (bfd_vma
) -1)
1230 Elf_Internal_Rel rel
;
1232 /* This symbol has an entry in the procedure linkage table. Set
1235 BFD_ASSERT (h
->dynindx
!= -1);
1237 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1238 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1239 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
1240 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1242 /* Get the index in the procedure linkage table which
1243 corresponds to this symbol. This is the index of this symbol
1244 in all the symbols for which we are making plt entries. The
1245 first entry in the procedure linkage table is reserved. */
1246 plt_index
= h
->plt_offset
/ PLT_ENTRY_SIZE
- 1;
1248 /* Get the offset into the .got table of the entry that
1249 corresponds to this function. Each .got entry is 4 bytes.
1250 The first three are reserved. */
1251 got_offset
= (plt_index
+ 3) * 4;
1253 /* Fill in the entry in the procedure linkage table. */
1256 memcpy (splt
->contents
+ h
->plt_offset
, elf_i386_plt_entry
,
1258 bfd_put_32 (output_bfd
,
1259 (sgot
->output_section
->vma
1260 + sgot
->output_offset
1262 splt
->contents
+ h
->plt_offset
+ 2);
1266 memcpy (splt
->contents
+ h
->plt_offset
, elf_i386_pic_plt_entry
,
1268 bfd_put_32 (output_bfd
, got_offset
,
1269 splt
->contents
+ h
->plt_offset
+ 2);
1272 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1273 splt
->contents
+ h
->plt_offset
+ 7);
1274 bfd_put_32 (output_bfd
, - (h
->plt_offset
+ PLT_ENTRY_SIZE
),
1275 splt
->contents
+ h
->plt_offset
+ 12);
1277 /* Fill in the entry in the global offset table. */
1278 bfd_put_32 (output_bfd
,
1279 (splt
->output_section
->vma
1280 + splt
->output_offset
1283 sgot
->contents
+ got_offset
);
1285 /* Fill in the entry in the .rel.plt section. */
1286 rel
.r_offset
= (sgot
->output_section
->vma
1287 + sgot
->output_offset
1289 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1290 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1291 ((Elf32_External_Rel
*) srel
->contents
1294 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1296 /* Mark the symbol as undefined, rather than as defined in
1297 the .plt section. Leave the value alone. */
1298 sym
->st_shndx
= SHN_UNDEF
;
1302 if (h
->got_offset
!= (bfd_vma
) -1)
1306 Elf_Internal_Rel rel
;
1308 /* This symbol has an entry in the global offset table. Set it
1311 BFD_ASSERT (h
->dynindx
!= -1);
1313 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1314 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
1315 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
1317 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got_offset
);
1319 rel
.r_offset
= (sgot
->output_section
->vma
1320 + sgot
->output_offset
1322 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
1323 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1324 ((Elf32_External_Rel
*) srel
->contents
1325 + srel
->reloc_count
));
1326 ++srel
->reloc_count
;
1329 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1332 Elf_Internal_Rel rel
;
1334 /* This symbol needs a copy reloc. Set it up. */
1336 BFD_ASSERT (h
->dynindx
!= -1
1337 && (h
->root
.type
== bfd_link_hash_defined
1338 || h
->root
.type
== bfd_link_hash_defweak
));
1340 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1342 BFD_ASSERT (s
!= NULL
);
1344 rel
.r_offset
= (h
->root
.u
.def
.value
1345 + h
->root
.u
.def
.section
->output_section
->vma
1346 + h
->root
.u
.def
.section
->output_offset
);
1347 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
1348 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1349 ((Elf32_External_Rel
*) s
->contents
1354 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1355 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1356 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1357 sym
->st_shndx
= SHN_ABS
;
1362 /* Finish up the dynamic sections. */
1365 elf_i386_finish_dynamic_sections (output_bfd
, info
)
1367 struct bfd_link_info
*info
;
1373 dynobj
= elf_hash_table (info
)->dynobj
;
1375 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1376 BFD_ASSERT (sgot
!= NULL
);
1377 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1379 if (elf_hash_table (info
)->dynamic_sections_created
)
1382 Elf32_External_Dyn
*dyncon
, *dynconend
;
1384 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1385 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1387 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1388 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1389 for (; dyncon
< dynconend
; dyncon
++)
1391 Elf_Internal_Dyn dyn
;
1395 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1408 s
= bfd_get_section_by_name (output_bfd
, name
);
1409 BFD_ASSERT (s
!= NULL
);
1410 dyn
.d_un
.d_ptr
= s
->vma
;
1411 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1415 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
1416 BFD_ASSERT (s
!= NULL
);
1417 if (s
->_cooked_size
!= 0)
1418 dyn
.d_un
.d_val
= s
->_cooked_size
;
1420 dyn
.d_un
.d_val
= s
->_raw_size
;
1421 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1425 /* My reading of the SVR4 ABI indicates that the
1426 procedure linkage table relocs (DT_JMPREL) should be
1427 included in the overall relocs (DT_REL). This is
1428 what Solaris does. However, UnixWare can not handle
1429 that case. Therefore, we override the DT_RELSZ entry
1430 here to make it not include the JMPREL relocs. Since
1431 the linker script arranges for .rel.plt to follow all
1432 other relocation sections, we don't have to worry
1433 about changing the DT_REL entry. */
1434 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
1437 if (s
->_cooked_size
!= 0)
1438 dyn
.d_un
.d_val
-= s
->_cooked_size
;
1440 dyn
.d_un
.d_val
-= s
->_raw_size
;
1442 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1447 /* Fill in the first entry in the procedure linkage table. */
1448 if (splt
->_raw_size
> 0)
1451 memcpy (splt
->contents
, elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
1454 memcpy (splt
->contents
, elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
1455 bfd_put_32 (output_bfd
,
1456 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
1457 splt
->contents
+ 2);
1458 bfd_put_32 (output_bfd
,
1459 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
1460 splt
->contents
+ 8);
1464 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1465 really seem like the right value. */
1466 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
1469 /* Fill in the first three entries in the global offset table. */
1470 if (sgot
->_raw_size
> 0)
1473 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1475 bfd_put_32 (output_bfd
,
1476 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1478 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1479 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1482 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1487 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1488 #define TARGET_LITTLE_NAME "elf32-i386"
1489 #define ELF_ARCH bfd_arch_i386
1490 #define ELF_MACHINE_CODE EM_386
1491 #define elf_info_to_howto elf_i386_info_to_howto
1492 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1493 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1494 #define ELF_MAXPAGESIZE 0x1000
1495 #define elf_backend_create_dynamic_sections \
1496 _bfd_elf_create_dynamic_sections
1497 #define elf_backend_check_relocs elf_i386_check_relocs
1498 #define elf_backend_adjust_dynamic_symbol \
1499 elf_i386_adjust_dynamic_symbol
1500 #define elf_backend_size_dynamic_sections \
1501 elf_i386_size_dynamic_sections
1502 #define elf_backend_relocate_section elf_i386_relocate_section
1503 #define elf_backend_finish_dynamic_symbol \
1504 elf_i386_finish_dynamic_symbol
1505 #define elf_backend_finish_dynamic_sections \
1506 elf_i386_finish_dynamic_sections
1507 #define elf_backend_want_got_plt 1
1508 #define elf_backend_plt_readonly 0
1509 #define elf_backend_want_plt_sym 0
1511 #include "elf32-target.h"