1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993-1997, 1998 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 static reloc_howto_type *elf_i386_reloc_type_lookup
29 PARAMS ((bfd *, bfd_reloc_code_real_type));
30 static void elf_i386_info_to_howto
31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
32 static void elf_i386_info_to_howto_rel
33 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
34 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
35 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
36 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
37 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
39 static boolean elf_i386_check_relocs
40 PARAMS ((bfd *, struct bfd_link_info *, asection *,
41 const Elf_Internal_Rela *));
42 static boolean elf_i386_adjust_dynamic_symbol
43 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
44 static boolean elf_i386_size_dynamic_sections
45 PARAMS ((bfd *, struct bfd_link_info *));
46 static boolean elf_i386_relocate_section
47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
49 static boolean elf_i386_finish_dynamic_symbol
50 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
52 static boolean elf_i386_finish_dynamic_sections
53 PARAMS ((bfd *, struct bfd_link_info *));
55 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
71 LAST_INVALID_RELOC = 19,
72 /* The remaining relocs are a GNU extension. */
81 static CONST char *CONST reloc_type_names[] =
97 static reloc_howto_type elf_howto_table[]=
99 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false),
100 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false),
101 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true),
102 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
103 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
104 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false),
105 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),
106 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),
107 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
108 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
109 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
119 /* The remaining relocs are a GNU extension. */
120 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false),
121 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true),
122 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false),
123 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true),
126 #ifdef DEBUG_GEN_RELOC
127 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
132 static reloc_howto_type *
133 elf_i386_reloc_type_lookup (abfd, code)
135 bfd_reloc_code_real_type code;
140 TRACE ("BFD_RELOC_NONE");
141 return &elf_howto_table[ (int)R_386_NONE ];
144 TRACE ("BFD_RELOC_32");
145 return &elf_howto_table[ (int)R_386_32 ];
147 case BFD_RELOC_32_PCREL:
148 TRACE ("BFD_RELOC_PC32");
149 return &elf_howto_table[ (int)R_386_PC32 ];
151 case BFD_RELOC_386_GOT32:
152 TRACE ("BFD_RELOC_386_GOT32");
153 return &elf_howto_table[ (int)R_386_GOT32 ];
155 case BFD_RELOC_386_PLT32:
156 TRACE ("BFD_RELOC_386_PLT32");
157 return &elf_howto_table[ (int)R_386_PLT32 ];
159 case BFD_RELOC_386_COPY:
160 TRACE ("BFD_RELOC_386_COPY");
161 return &elf_howto_table[ (int)R_386_COPY ];
163 case BFD_RELOC_386_GLOB_DAT:
164 TRACE ("BFD_RELOC_386_GLOB_DAT");
165 return &elf_howto_table[ (int)R_386_GLOB_DAT ];
167 case BFD_RELOC_386_JUMP_SLOT:
168 TRACE ("BFD_RELOC_386_JUMP_SLOT");
169 return &elf_howto_table[ (int)R_386_JUMP_SLOT ];
171 case BFD_RELOC_386_RELATIVE:
172 TRACE ("BFD_RELOC_386_RELATIVE");
173 return &elf_howto_table[ (int)R_386_RELATIVE ];
175 case BFD_RELOC_386_GOTOFF:
176 TRACE ("BFD_RELOC_386_GOTOFF");
177 return &elf_howto_table[ (int)R_386_GOTOFF ];
179 case BFD_RELOC_386_GOTPC:
180 TRACE ("BFD_RELOC_386_GOTPC");
181 return &elf_howto_table[ (int)R_386_GOTPC ];
183 /* The remaining relocs are a GNU extension. */
185 TRACE ("BFD_RELOC_16");
186 return &elf_howto_table[(int) R_386_16];
188 case BFD_RELOC_16_PCREL:
189 TRACE ("BFD_RELOC_16_PCREL");
190 return &elf_howto_table[(int) R_386_PC16];
193 TRACE ("BFD_RELOC_8");
194 return &elf_howto_table[(int) R_386_8];
196 case BFD_RELOC_8_PCREL:
197 TRACE ("BFD_RELOC_8_PCREL");
198 return &elf_howto_table[(int) R_386_PC8];
209 elf_i386_info_to_howto (abfd, cache_ptr, dst)
212 Elf32_Internal_Rela *dst;
218 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
221 Elf32_Internal_Rel *dst;
223 enum reloc_type type;
225 type = (enum reloc_type) ELF32_R_TYPE (dst->r_info);
226 BFD_ASSERT (type < R_386_max);
227 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC);
229 cache_ptr->howto = &elf_howto_table[(int) type];
232 /* Return whether a symbol name implies a local label. The UnixWare
233 2.1 cc generates temporary symbols that start with .X, so we
234 recognize them here. FIXME: do other SVR4 compilers also use .X?.
235 If so, we should move the .X recognition into
236 _bfd_elf_is_local_label_name. */
239 elf_i386_is_local_label_name (abfd, name)
243 if (name[0] == '.' && name[1] == 'X')
246 return _bfd_elf_is_local_label_name (abfd, name);
249 /* Functions for the i386 ELF linker. */
251 /* The name of the dynamic interpreter. This is put in the .interp
254 #if defined(__FreeBSD__)
255 #define ELF_DYNAMIC_INTERPRETER "/usr/libexec/ld-elf.so.1"
257 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
260 /* The size in bytes of an entry in the procedure linkage table. */
262 #define PLT_ENTRY_SIZE 16
264 /* The first entry in an absolute procedure linkage table looks like
265 this. See the SVR4 ABI i386 supplement to see how this works. */
267 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
269 0xff, 0x35, /* pushl contents of address */
270 0, 0, 0, 0, /* replaced with address of .got + 4. */
271 0xff, 0x25, /* jmp indirect */
272 0, 0, 0, 0, /* replaced with address of .got + 8. */
273 0, 0, 0, 0 /* pad out to 16 bytes. */
276 /* Subsequent entries in an absolute procedure linkage table look like
279 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
281 0xff, 0x25, /* jmp indirect */
282 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
283 0x68, /* pushl immediate */
284 0, 0, 0, 0, /* replaced with offset into relocation table. */
285 0xe9, /* jmp relative */
286 0, 0, 0, 0 /* replaced with offset to start of .plt. */
289 /* The first entry in a PIC procedure linkage table look like this. */
291 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
293 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
294 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
295 0, 0, 0, 0 /* pad out to 16 bytes. */
298 /* Subsequent entries in a PIC procedure linkage table look like this. */
300 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
302 0xff, 0xa3, /* jmp *offset(%ebx) */
303 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
304 0x68, /* pushl immediate */
305 0, 0, 0, 0, /* replaced with offset into relocation table. */
306 0xe9, /* jmp relative */
307 0, 0, 0, 0 /* replaced with offset to start of .plt. */
310 /* The i386 linker needs to keep track of the number of relocs that it
311 decides to copy in check_relocs for each symbol. This is so that
312 it can discard PC relative relocs if it doesn't need them when
313 linking with -Bsymbolic. We store the information in a field
314 extending the regular ELF linker hash table. */
316 /* This structure keeps track of the number of PC relative relocs we
317 have copied for a given symbol. */
319 struct elf_i386_pcrel_relocs_copied
322 struct elf_i386_pcrel_relocs_copied *next;
323 /* A section in dynobj. */
325 /* Number of relocs copied in this section. */
329 /* i386 ELF linker hash entry. */
331 struct elf_i386_link_hash_entry
333 struct elf_link_hash_entry root;
335 /* Number of PC relative relocs copied for this symbol. */
336 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
339 /* i386 ELF linker hash table. */
341 struct elf_i386_link_hash_table
343 struct elf_link_hash_table root;
346 /* Declare this now that the above structures are defined. */
348 static boolean elf_i386_discard_copies
349 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
351 /* Traverse an i386 ELF linker hash table. */
353 #define elf_i386_link_hash_traverse(table, func, info) \
354 (elf_link_hash_traverse \
356 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
359 /* Get the i386 ELF linker hash table from a link_info structure. */
361 #define elf_i386_hash_table(p) \
362 ((struct elf_i386_link_hash_table *) ((p)->hash))
364 /* Create an entry in an i386 ELF linker hash table. */
366 static struct bfd_hash_entry *
367 elf_i386_link_hash_newfunc (entry, table, string)
368 struct bfd_hash_entry *entry;
369 struct bfd_hash_table *table;
372 struct elf_i386_link_hash_entry *ret =
373 (struct elf_i386_link_hash_entry *) entry;
375 /* Allocate the structure if it has not already been allocated by a
377 if (ret == (struct elf_i386_link_hash_entry *) NULL)
378 ret = ((struct elf_i386_link_hash_entry *)
379 bfd_hash_allocate (table,
380 sizeof (struct elf_i386_link_hash_entry)));
381 if (ret == (struct elf_i386_link_hash_entry *) NULL)
382 return (struct bfd_hash_entry *) ret;
384 /* Call the allocation method of the superclass. */
385 ret = ((struct elf_i386_link_hash_entry *)
386 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
388 if (ret != (struct elf_i386_link_hash_entry *) NULL)
390 ret->pcrel_relocs_copied = NULL;
393 return (struct bfd_hash_entry *) ret;
396 /* Create an i386 ELF linker hash table. */
398 static struct bfd_link_hash_table *
399 elf_i386_link_hash_table_create (abfd)
402 struct elf_i386_link_hash_table *ret;
404 ret = ((struct elf_i386_link_hash_table *)
405 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
406 if (ret == (struct elf_i386_link_hash_table *) NULL)
409 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
410 elf_i386_link_hash_newfunc))
412 bfd_release (abfd, ret);
416 return &ret->root.root;
419 /* Look through the relocs for a section during the first phase, and
420 allocate space in the global offset table or procedure linkage
424 elf_i386_check_relocs (abfd, info, sec, relocs)
426 struct bfd_link_info *info;
428 const Elf_Internal_Rela *relocs;
431 Elf_Internal_Shdr *symtab_hdr;
432 struct elf_link_hash_entry **sym_hashes;
433 bfd_vma *local_got_offsets;
434 const Elf_Internal_Rela *rel;
435 const Elf_Internal_Rela *rel_end;
440 if (info->relocateable)
443 dynobj = elf_hash_table (info)->dynobj;
444 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
445 sym_hashes = elf_sym_hashes (abfd);
446 local_got_offsets = elf_local_got_offsets (abfd);
452 rel_end = relocs + sec->reloc_count;
453 for (rel = relocs; rel < rel_end; rel++)
455 unsigned long r_symndx;
456 struct elf_link_hash_entry *h;
458 r_symndx = ELF32_R_SYM (rel->r_info);
460 if (r_symndx < symtab_hdr->sh_info)
463 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
465 /* Some relocs require a global offset table. */
468 switch (ELF32_R_TYPE (rel->r_info))
473 elf_hash_table (info)->dynobj = dynobj = abfd;
474 if (! _bfd_elf_create_got_section (dynobj, info))
483 switch (ELF32_R_TYPE (rel->r_info))
486 /* This symbol requires a global offset table entry. */
490 sgot = bfd_get_section_by_name (dynobj, ".got");
491 BFD_ASSERT (sgot != NULL);
495 && (h != NULL || info->shared))
497 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
500 srelgot = bfd_make_section (dynobj, ".rel.got");
502 || ! bfd_set_section_flags (dynobj, srelgot,
509 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
516 if (h->got_offset != (bfd_vma) -1)
518 /* We have already allocated space in the .got. */
521 h->got_offset = sgot->_raw_size;
523 /* Make sure this symbol is output as a dynamic symbol. */
524 if (h->dynindx == -1)
526 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
530 srelgot->_raw_size += sizeof (Elf32_External_Rel);
534 /* This is a global offset table entry for a local
536 if (local_got_offsets == NULL)
539 register unsigned int i;
541 size = symtab_hdr->sh_info * sizeof (bfd_vma);
542 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
543 if (local_got_offsets == NULL)
545 elf_local_got_offsets (abfd) = local_got_offsets;
546 for (i = 0; i < symtab_hdr->sh_info; i++)
547 local_got_offsets[i] = (bfd_vma) -1;
549 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
551 /* We have already allocated space in the .got. */
554 local_got_offsets[r_symndx] = sgot->_raw_size;
558 /* If we are generating a shared object, we need to
559 output a R_386_RELATIVE reloc so that the dynamic
560 linker can adjust this GOT entry. */
561 srelgot->_raw_size += sizeof (Elf32_External_Rel);
565 sgot->_raw_size += 4;
570 /* This symbol requires a procedure linkage table entry. We
571 actually build the entry in adjust_dynamic_symbol,
572 because this might be a case of linking PIC code which is
573 never referenced by a dynamic object, in which case we
574 don't need to generate a procedure linkage table entry
577 /* If this is a local symbol, we resolve it directly without
578 creating a procedure linkage table entry. */
582 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
588 /* If we are creating a shared library, and this is a reloc
589 against a global symbol, or a non PC relative reloc
590 against a local symbol, then we need to copy the reloc
591 into the shared library. However, if we are linking with
592 -Bsymbolic, we do not need to copy a reloc against a
593 global symbol which is defined in an object we are
594 including in the link (i.e., DEF_REGULAR is set). At
595 this point we have not seen all the input files, so it is
596 possible that DEF_REGULAR is not set now but will be set
597 later (it is never cleared). We account for that
598 possibility below by storing information in the
599 pcrel_relocs_copied field of the hash table entry. */
601 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
604 || (h->elf_link_hash_flags
605 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
607 /* When creating a shared object, we must copy these
608 reloc types into the output file. We create a reloc
609 section in dynobj and make room for this reloc. */
614 name = (bfd_elf_string_from_elf_section
616 elf_elfheader (abfd)->e_shstrndx,
617 elf_section_data (sec)->rel_hdr.sh_name));
621 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
622 && strcmp (bfd_get_section_name (abfd, sec),
625 sreloc = bfd_get_section_by_name (dynobj, name);
630 sreloc = bfd_make_section (dynobj, name);
631 flags = (SEC_HAS_CONTENTS | SEC_READONLY
632 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
633 if ((sec->flags & SEC_ALLOC) != 0)
634 flags |= SEC_ALLOC | SEC_LOAD;
636 || ! bfd_set_section_flags (dynobj, sreloc, flags)
637 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
642 sreloc->_raw_size += sizeof (Elf32_External_Rel);
644 /* If we are linking with -Bsymbolic, and this is a
645 global symbol, we count the number of PC relative
646 relocations we have entered for this symbol, so that
647 we can discard them again if the symbol is later
648 defined by a regular object. Note that this function
649 is only called if we are using an elf_i386 linker
650 hash table, which means that h is really a pointer to
651 an elf_i386_link_hash_entry. */
652 if (h != NULL && info->symbolic
653 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
655 struct elf_i386_link_hash_entry *eh;
656 struct elf_i386_pcrel_relocs_copied *p;
658 eh = (struct elf_i386_link_hash_entry *) h;
660 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
661 if (p->section == sreloc)
666 p = ((struct elf_i386_pcrel_relocs_copied *)
667 bfd_alloc (dynobj, sizeof *p));
670 p->next = eh->pcrel_relocs_copied;
671 eh->pcrel_relocs_copied = p;
690 /* Adjust a symbol defined by a dynamic object and referenced by a
691 regular object. The current definition is in some section of the
692 dynamic object, but we're not including those sections. We have to
693 change the definition to something the rest of the link can
697 elf_i386_adjust_dynamic_symbol (info, h)
698 struct bfd_link_info *info;
699 struct elf_link_hash_entry *h;
703 unsigned int power_of_two;
705 dynobj = elf_hash_table (info)->dynobj;
707 /* Make sure we know what is going on here. */
708 BFD_ASSERT (dynobj != NULL
709 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
710 || h->weakdef != NULL
711 || ((h->elf_link_hash_flags
712 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
713 && (h->elf_link_hash_flags
714 & ELF_LINK_HASH_REF_REGULAR) != 0
715 && (h->elf_link_hash_flags
716 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
718 /* If this is a function, put it in the procedure linkage table. We
719 will fill in the contents of the procedure linkage table later,
720 when we know the address of the .got section. */
721 if (h->type == STT_FUNC
722 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
725 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
726 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
728 /* This case can occur if we saw a PLT32 reloc in an input
729 file, but the symbol was never referred to by a dynamic
730 object. In such a case, we don't actually need to build
731 a procedure linkage table, and we can just do a PC32
733 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
737 /* Make sure this symbol is output as a dynamic symbol. */
738 if (h->dynindx == -1)
740 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
744 s = bfd_get_section_by_name (dynobj, ".plt");
745 BFD_ASSERT (s != NULL);
747 /* If this is the first .plt entry, make room for the special
749 if (s->_raw_size == 0)
750 s->_raw_size += PLT_ENTRY_SIZE;
752 /* If this symbol is not defined in a regular file, and we are
753 not generating a shared library, then set the symbol to this
754 location in the .plt. This is required to make function
755 pointers compare as equal between the normal executable and
756 the shared library. */
758 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
760 h->root.u.def.section = s;
761 h->root.u.def.value = s->_raw_size;
764 h->plt_offset = s->_raw_size;
766 /* Make room for this entry. */
767 s->_raw_size += PLT_ENTRY_SIZE;
769 /* We also need to make an entry in the .got.plt section, which
770 will be placed in the .got section by the linker script. */
772 s = bfd_get_section_by_name (dynobj, ".got.plt");
773 BFD_ASSERT (s != NULL);
776 /* We also need to make an entry in the .rel.plt section. */
778 s = bfd_get_section_by_name (dynobj, ".rel.plt");
779 BFD_ASSERT (s != NULL);
780 s->_raw_size += sizeof (Elf32_External_Rel);
785 /* If this is a weak symbol, and there is a real definition, the
786 processor independent code will have arranged for us to see the
787 real definition first, and we can just use the same value. */
788 if (h->weakdef != NULL)
790 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
791 || h->weakdef->root.type == bfd_link_hash_defweak);
792 h->root.u.def.section = h->weakdef->root.u.def.section;
793 h->root.u.def.value = h->weakdef->root.u.def.value;
797 /* This is a reference to a symbol defined by a dynamic object which
798 is not a function. */
800 /* If we are creating a shared library, we must presume that the
801 only references to the symbol are via the global offset table.
802 For such cases we need not do anything here; the relocations will
803 be handled correctly by relocate_section. */
807 /* We must allocate the symbol in our .dynbss section, which will
808 become part of the .bss section of the executable. There will be
809 an entry for this symbol in the .dynsym section. The dynamic
810 object will contain position independent code, so all references
811 from the dynamic object to this symbol will go through the global
812 offset table. The dynamic linker will use the .dynsym entry to
813 determine the address it must put in the global offset table, so
814 both the dynamic object and the regular object will refer to the
815 same memory location for the variable. */
817 s = bfd_get_section_by_name (dynobj, ".dynbss");
818 BFD_ASSERT (s != NULL);
820 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
821 copy the initial value out of the dynamic object and into the
822 runtime process image. We need to remember the offset into the
823 .rel.bss section we are going to use. */
824 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
828 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
829 BFD_ASSERT (srel != NULL);
830 srel->_raw_size += sizeof (Elf32_External_Rel);
831 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
834 /* We need to figure out the alignment required for this symbol. I
835 have no idea how ELF linkers handle this. */
836 power_of_two = bfd_log2 (h->size);
837 if (power_of_two > 3)
840 /* Apply the required alignment. */
841 s->_raw_size = BFD_ALIGN (s->_raw_size,
842 (bfd_size_type) (1 << power_of_two));
843 if (power_of_two > bfd_get_section_alignment (dynobj, s))
845 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
849 /* Define the symbol as being at this point in the section. */
850 h->root.u.def.section = s;
851 h->root.u.def.value = s->_raw_size;
853 /* Increment the section size to make room for the symbol. */
854 s->_raw_size += h->size;
859 /* Set the sizes of the dynamic sections. */
862 elf_i386_size_dynamic_sections (output_bfd, info)
864 struct bfd_link_info *info;
872 dynobj = elf_hash_table (info)->dynobj;
873 BFD_ASSERT (dynobj != NULL);
875 if (elf_hash_table (info)->dynamic_sections_created)
877 /* Set the contents of the .interp section to the interpreter. */
880 s = bfd_get_section_by_name (dynobj, ".interp");
881 BFD_ASSERT (s != NULL);
882 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
883 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
888 /* We may have created entries in the .rel.got section.
889 However, if we are not creating the dynamic sections, we will
890 not actually use these entries. Reset the size of .rel.got,
891 which will cause it to get stripped from the output file
893 s = bfd_get_section_by_name (dynobj, ".rel.got");
898 /* If this is a -Bsymbolic shared link, then we need to discard all
899 PC relative relocs against symbols defined in a regular object.
900 We allocated space for them in the check_relocs routine, but we
901 will not fill them in in the relocate_section routine. */
902 if (info->shared && info->symbolic)
903 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
904 elf_i386_discard_copies,
907 /* The check_relocs and adjust_dynamic_symbol entry points have
908 determined the sizes of the various dynamic sections. Allocate
913 for (s = dynobj->sections; s != NULL; s = s->next)
918 if ((s->flags & SEC_LINKER_CREATED) == 0)
921 /* It's OK to base decisions on the section name, because none
922 of the dynobj section names depend upon the input files. */
923 name = bfd_get_section_name (dynobj, s);
927 if (strcmp (name, ".plt") == 0)
929 if (s->_raw_size == 0)
931 /* Strip this section if we don't need it; see the
937 /* Remember whether there is a PLT. */
941 else if (strncmp (name, ".rel", 4) == 0)
943 if (s->_raw_size == 0)
945 /* If we don't need this section, strip it from the
946 output file. This is mostly to handle .rel.bss and
947 .rel.plt. We must create both sections in
948 create_dynamic_sections, because they must be created
949 before the linker maps input sections to output
950 sections. The linker does that before
951 adjust_dynamic_symbol is called, and it is that
952 function which decides whether anything needs to go
953 into these sections. */
960 /* Remember whether there are any reloc sections other
962 if (strcmp (name, ".rel.plt") != 0)
968 /* If this relocation section applies to a read only
969 section, then we probably need a DT_TEXTREL
970 entry. The entries in the .rel.plt section
971 really apply to the .got section, which we
972 created ourselves and so know is not readonly. */
973 outname = bfd_get_section_name (output_bfd,
975 target = bfd_get_section_by_name (output_bfd, outname + 4);
977 && (target->flags & SEC_READONLY) != 0
978 && (target->flags & SEC_ALLOC) != 0)
982 /* We use the reloc_count field as a counter if we need
983 to copy relocs into the output file. */
987 else if (strncmp (name, ".got", 4) != 0)
989 /* It's not one of our sections, so don't allocate space. */
997 for (spp = &s->output_section->owner->sections;
998 *spp != s->output_section;
1001 *spp = s->output_section->next;
1002 --s->output_section->owner->section_count;
1007 /* Allocate memory for the section contents. */
1008 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1009 if (s->contents == NULL && s->_raw_size != 0)
1013 if (elf_hash_table (info)->dynamic_sections_created)
1015 /* Add some entries to the .dynamic section. We fill in the
1016 values later, in elf_i386_finish_dynamic_sections, but we
1017 must add the entries now so that we get the correct size for
1018 the .dynamic section. The DT_DEBUG entry is filled in by the
1019 dynamic linker and used by the debugger. */
1022 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1028 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1029 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1030 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1031 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1037 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1038 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1039 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1040 sizeof (Elf32_External_Rel)))
1046 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1054 /* This function is called via elf_i386_link_hash_traverse if we are
1055 creating a shared object with -Bsymbolic. It discards the space
1056 allocated to copy PC relative relocs against symbols which are
1057 defined in regular objects. We allocated space for them in the
1058 check_relocs routine, but we won't fill them in in the
1059 relocate_section routine. */
1063 elf_i386_discard_copies (h, ignore)
1064 struct elf_i386_link_hash_entry *h;
1067 struct elf_i386_pcrel_relocs_copied *s;
1069 /* We only discard relocs for symbols defined in a regular object. */
1070 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1073 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1074 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1079 /* Relocate an i386 ELF section. */
1082 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1083 contents, relocs, local_syms, local_sections)
1085 struct bfd_link_info *info;
1087 asection *input_section;
1089 Elf_Internal_Rela *relocs;
1090 Elf_Internal_Sym *local_syms;
1091 asection **local_sections;
1094 Elf_Internal_Shdr *symtab_hdr;
1095 struct elf_link_hash_entry **sym_hashes;
1096 bfd_vma *local_got_offsets;
1100 Elf_Internal_Rela *rel;
1101 Elf_Internal_Rela *relend;
1103 dynobj = elf_hash_table (info)->dynobj;
1104 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1105 sym_hashes = elf_sym_hashes (input_bfd);
1106 local_got_offsets = elf_local_got_offsets (input_bfd);
1113 relend = relocs + input_section->reloc_count;
1114 for (; rel < relend; rel++)
1117 reloc_howto_type *howto;
1118 unsigned long r_symndx;
1119 struct elf_link_hash_entry *h;
1120 Elf_Internal_Sym *sym;
1123 bfd_reloc_status_type r;
1125 r_type = ELF32_R_TYPE (rel->r_info);
1127 || r_type >= (int) R_386_max
1128 || (r_type >= (int) FIRST_INVALID_RELOC
1129 && r_type <= (int) LAST_INVALID_RELOC))
1131 bfd_set_error (bfd_error_bad_value);
1134 howto = elf_howto_table + r_type;
1136 r_symndx = ELF32_R_SYM (rel->r_info);
1138 if (info->relocateable)
1140 /* This is a relocateable link. We don't have to change
1141 anything, unless the reloc is against a section symbol,
1142 in which case we have to adjust according to where the
1143 section symbol winds up in the output section. */
1144 if (r_symndx < symtab_hdr->sh_info)
1146 sym = local_syms + r_symndx;
1147 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1151 sec = local_sections[r_symndx];
1152 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1153 val += sec->output_offset + sym->st_value;
1154 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1161 /* This is a final link. */
1165 if (r_symndx < symtab_hdr->sh_info)
1167 sym = local_syms + r_symndx;
1168 sec = local_sections[r_symndx];
1169 relocation = (sec->output_section->vma
1170 + sec->output_offset
1175 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1176 while (h->root.type == bfd_link_hash_indirect
1177 || h->root.type == bfd_link_hash_warning)
1178 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1179 if (h->root.type == bfd_link_hash_defined
1180 || h->root.type == bfd_link_hash_defweak)
1182 sec = h->root.u.def.section;
1183 if (r_type == R_386_GOTPC
1184 || (r_type == R_386_PLT32
1185 && h->plt_offset != (bfd_vma) -1)
1186 || (r_type == R_386_GOT32
1187 && elf_hash_table (info)->dynamic_sections_created
1189 || (! info->symbolic && h->dynindx != -1)
1190 || (h->elf_link_hash_flags
1191 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1193 && ((! info->symbolic && h->dynindx != -1)
1194 || (h->elf_link_hash_flags
1195 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1196 && (r_type == R_386_32
1197 || r_type == R_386_PC32)
1198 && (input_section->flags & SEC_ALLOC) != 0))
1200 /* In these cases, we don't need the relocation
1201 value. We check specially because in some
1202 obscure cases sec->output_section will be NULL. */
1205 else if (sec->output_section == NULL)
1207 (*_bfd_error_handler)
1208 ("%s: warning: unresolvable relocation against symbol `%s' from %s section",
1209 bfd_get_filename (input_bfd), h->root.root.string,
1210 bfd_get_section_name (input_bfd, input_section));
1214 relocation = (h->root.u.def.value
1215 + sec->output_section->vma
1216 + sec->output_offset);
1218 else if (h->root.type == bfd_link_hash_undefweak)
1220 else if (info->shared && !info->symbolic)
1224 if (! ((*info->callbacks->undefined_symbol)
1225 (info, h->root.root.string, input_bfd,
1226 input_section, rel->r_offset)))
1235 /* Relocation is to the entry for this symbol in the global
1239 sgot = bfd_get_section_by_name (dynobj, ".got");
1240 BFD_ASSERT (sgot != NULL);
1247 off = h->got_offset;
1248 BFD_ASSERT (off != (bfd_vma) -1);
1250 if (! elf_hash_table (info)->dynamic_sections_created
1252 && (info->symbolic || h->dynindx == -1)
1253 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1255 /* This is actually a static link, or it is a
1256 -Bsymbolic link and the symbol is defined
1257 locally, or the symbol was forced to be local
1258 because of a version file. We must initialize
1259 this entry in the global offset table. Since the
1260 offset must always be a multiple of 4, we use the
1261 least significant bit to record whether we have
1262 initialized it already.
1264 When doing a dynamic link, we create a .rel.got
1265 relocation entry to initialize the value. This
1266 is done in the finish_dynamic_symbol routine. */
1271 bfd_put_32 (output_bfd, relocation,
1272 sgot->contents + off);
1277 relocation = sgot->output_offset + off;
1283 BFD_ASSERT (local_got_offsets != NULL
1284 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1286 off = local_got_offsets[r_symndx];
1288 /* The offset must always be a multiple of 4. We use
1289 the least significant bit to record whether we have
1290 already generated the necessary reloc. */
1295 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1300 Elf_Internal_Rel outrel;
1302 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1303 BFD_ASSERT (srelgot != NULL);
1305 outrel.r_offset = (sgot->output_section->vma
1306 + sgot->output_offset
1308 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1309 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1310 (((Elf32_External_Rel *)
1312 + srelgot->reloc_count));
1313 ++srelgot->reloc_count;
1316 local_got_offsets[r_symndx] |= 1;
1319 relocation = sgot->output_offset + off;
1325 /* Relocation is relative to the start of the global offset
1330 sgot = bfd_get_section_by_name (dynobj, ".got");
1331 BFD_ASSERT (sgot != NULL);
1334 /* Note that sgot->output_offset is not involved in this
1335 calculation. We always want the start of .got. If we
1336 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1337 permitted by the ABI, we might have to change this
1339 relocation -= sgot->output_section->vma;
1344 /* Use global offset table as symbol value. */
1348 sgot = bfd_get_section_by_name (dynobj, ".got");
1349 BFD_ASSERT (sgot != NULL);
1352 relocation = sgot->output_section->vma;
1357 /* Relocation is to the entry for this symbol in the
1358 procedure linkage table. */
1360 /* Resolve a PLT32 reloc again a local symbol directly,
1361 without using the procedure linkage table. */
1365 if (h->plt_offset == (bfd_vma) -1)
1367 /* We didn't make a PLT entry for this symbol. This
1368 happens when statically linking PIC code, or when
1369 using -Bsymbolic. */
1375 splt = bfd_get_section_by_name (dynobj, ".plt");
1376 BFD_ASSERT (splt != NULL);
1379 relocation = (splt->output_section->vma
1380 + splt->output_offset
1388 && (r_type != R_386_PC32
1391 && (! info->symbolic
1392 || (h->elf_link_hash_flags
1393 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1395 Elf_Internal_Rel outrel;
1396 boolean skip, relocate;
1398 /* When generating a shared object, these relocations
1399 are copied into the output file to be resolved at run
1406 name = (bfd_elf_string_from_elf_section
1408 elf_elfheader (input_bfd)->e_shstrndx,
1409 elf_section_data (input_section)->rel_hdr.sh_name));
1413 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1414 && strcmp (bfd_get_section_name (input_bfd,
1418 sreloc = bfd_get_section_by_name (dynobj, name);
1419 BFD_ASSERT (sreloc != NULL);
1424 if (elf_section_data (input_section)->stab_info == NULL)
1425 outrel.r_offset = rel->r_offset;
1430 off = (_bfd_stab_section_offset
1431 (output_bfd, &elf_hash_table (info)->stab_info,
1433 &elf_section_data (input_section)->stab_info,
1435 if (off == (bfd_vma) -1)
1437 outrel.r_offset = off;
1440 outrel.r_offset += (input_section->output_section->vma
1441 + input_section->output_offset);
1445 memset (&outrel, 0, sizeof outrel);
1448 else if (r_type == R_386_PC32)
1450 BFD_ASSERT (h != NULL && h->dynindx != -1);
1451 if ((input_section->flags & SEC_ALLOC) != 0)
1455 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1459 /* h->dynindx may be -1 if this symbol was marked to
1462 || ((info->symbolic || h->dynindx == -1)
1463 && (h->elf_link_hash_flags
1464 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1467 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1471 BFD_ASSERT (h->dynindx != -1);
1472 if ((input_section->flags & SEC_ALLOC) != 0)
1476 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1480 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1481 (((Elf32_External_Rel *)
1483 + sreloc->reloc_count));
1484 ++sreloc->reloc_count;
1486 /* If this reloc is against an external symbol, we do
1487 not want to fiddle with the addend. Otherwise, we
1488 need to include the symbol value so that it becomes
1489 an addend for the dynamic reloc. */
1500 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1501 contents, rel->r_offset,
1502 relocation, (bfd_vma) 0);
1504 if (r != bfd_reloc_ok)
1509 case bfd_reloc_outofrange:
1511 case bfd_reloc_overflow:
1516 name = h->root.root.string;
1519 name = bfd_elf_string_from_elf_section (input_bfd,
1520 symtab_hdr->sh_link,
1525 name = bfd_section_name (input_bfd, sec);
1527 if (! ((*info->callbacks->reloc_overflow)
1528 (info, name, howto->name, (bfd_vma) 0,
1529 input_bfd, input_section, rel->r_offset)))
1540 /* Finish up dynamic symbol handling. We set the contents of various
1541 dynamic sections here. */
1544 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1546 struct bfd_link_info *info;
1547 struct elf_link_hash_entry *h;
1548 Elf_Internal_Sym *sym;
1552 dynobj = elf_hash_table (info)->dynobj;
1554 if (h->plt_offset != (bfd_vma) -1)
1561 Elf_Internal_Rel rel;
1563 /* This symbol has an entry in the procedure linkage table. Set
1566 BFD_ASSERT (h->dynindx != -1);
1568 splt = bfd_get_section_by_name (dynobj, ".plt");
1569 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1570 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1571 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1573 /* Get the index in the procedure linkage table which
1574 corresponds to this symbol. This is the index of this symbol
1575 in all the symbols for which we are making plt entries. The
1576 first entry in the procedure linkage table is reserved. */
1577 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1;
1579 /* Get the offset into the .got table of the entry that
1580 corresponds to this function. Each .got entry is 4 bytes.
1581 The first three are reserved. */
1582 got_offset = (plt_index + 3) * 4;
1584 /* Fill in the entry in the procedure linkage table. */
1587 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry,
1589 bfd_put_32 (output_bfd,
1590 (sgot->output_section->vma
1591 + sgot->output_offset
1593 splt->contents + h->plt_offset + 2);
1597 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry,
1599 bfd_put_32 (output_bfd, got_offset,
1600 splt->contents + h->plt_offset + 2);
1603 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1604 splt->contents + h->plt_offset + 7);
1605 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE),
1606 splt->contents + h->plt_offset + 12);
1608 /* Fill in the entry in the global offset table. */
1609 bfd_put_32 (output_bfd,
1610 (splt->output_section->vma
1611 + splt->output_offset
1614 sgot->contents + got_offset);
1616 /* Fill in the entry in the .rel.plt section. */
1617 rel.r_offset = (sgot->output_section->vma
1618 + sgot->output_offset
1620 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1621 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1622 ((Elf32_External_Rel *) srel->contents
1625 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1627 /* Mark the symbol as undefined, rather than as defined in
1628 the .plt section. Leave the value alone. */
1629 sym->st_shndx = SHN_UNDEF;
1633 if (h->got_offset != (bfd_vma) -1)
1637 Elf_Internal_Rel rel;
1639 /* This symbol has an entry in the global offset table. Set it
1642 sgot = bfd_get_section_by_name (dynobj, ".got");
1643 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1644 BFD_ASSERT (sgot != NULL && srel != NULL);
1646 rel.r_offset = (sgot->output_section->vma
1647 + sgot->output_offset
1648 + (h->got_offset &~ 1));
1650 /* If this is a -Bsymbolic link, and the symbol is defined
1651 locally, we just want to emit a RELATIVE reloc. Likewise if
1652 the symbol was forced to be local because of a version file.
1653 The entry in the global offset table will already have been
1654 initialized in the relocate_section function. */
1656 && (info->symbolic || h->dynindx == -1)
1657 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1658 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1661 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1662 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1665 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1666 ((Elf32_External_Rel *) srel->contents
1667 + srel->reloc_count));
1668 ++srel->reloc_count;
1671 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1674 Elf_Internal_Rel rel;
1676 /* This symbol needs a copy reloc. Set it up. */
1678 BFD_ASSERT (h->dynindx != -1
1679 && (h->root.type == bfd_link_hash_defined
1680 || h->root.type == bfd_link_hash_defweak));
1682 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1684 BFD_ASSERT (s != NULL);
1686 rel.r_offset = (h->root.u.def.value
1687 + h->root.u.def.section->output_section->vma
1688 + h->root.u.def.section->output_offset);
1689 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1690 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1691 ((Elf32_External_Rel *) s->contents
1696 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1697 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1698 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1699 sym->st_shndx = SHN_ABS;
1704 /* Finish up the dynamic sections. */
1707 elf_i386_finish_dynamic_sections (output_bfd, info)
1709 struct bfd_link_info *info;
1715 dynobj = elf_hash_table (info)->dynobj;
1717 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1718 BFD_ASSERT (sgot != NULL);
1719 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1721 if (elf_hash_table (info)->dynamic_sections_created)
1724 Elf32_External_Dyn *dyncon, *dynconend;
1726 splt = bfd_get_section_by_name (dynobj, ".plt");
1727 BFD_ASSERT (splt != NULL && sdyn != NULL);
1729 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1730 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1731 for (; dyncon < dynconend; dyncon++)
1733 Elf_Internal_Dyn dyn;
1737 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1750 s = bfd_get_section_by_name (output_bfd, name);
1751 BFD_ASSERT (s != NULL);
1752 dyn.d_un.d_ptr = s->vma;
1753 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1757 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1758 BFD_ASSERT (s != NULL);
1759 if (s->_cooked_size != 0)
1760 dyn.d_un.d_val = s->_cooked_size;
1762 dyn.d_un.d_val = s->_raw_size;
1763 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1767 /* My reading of the SVR4 ABI indicates that the
1768 procedure linkage table relocs (DT_JMPREL) should be
1769 included in the overall relocs (DT_REL). This is
1770 what Solaris does. However, UnixWare can not handle
1771 that case. Therefore, we override the DT_RELSZ entry
1772 here to make it not include the JMPREL relocs. Since
1773 the linker script arranges for .rel.plt to follow all
1774 other relocation sections, we don't have to worry
1775 about changing the DT_REL entry. */
1776 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1779 if (s->_cooked_size != 0)
1780 dyn.d_un.d_val -= s->_cooked_size;
1782 dyn.d_un.d_val -= s->_raw_size;
1784 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1789 /* Fill in the first entry in the procedure linkage table. */
1790 if (splt->_raw_size > 0)
1793 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1796 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1797 bfd_put_32 (output_bfd,
1798 sgot->output_section->vma + sgot->output_offset + 4,
1799 splt->contents + 2);
1800 bfd_put_32 (output_bfd,
1801 sgot->output_section->vma + sgot->output_offset + 8,
1802 splt->contents + 8);
1806 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1807 really seem like the right value. */
1808 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1811 /* Fill in the first three entries in the global offset table. */
1812 if (sgot->_raw_size > 0)
1815 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1817 bfd_put_32 (output_bfd,
1818 sdyn->output_section->vma + sdyn->output_offset,
1820 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1821 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1824 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1829 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1830 #define TARGET_LITTLE_NAME "elf32-i386"
1831 #define ELF_ARCH bfd_arch_i386
1832 #define ELF_MACHINE_CODE EM_386
1833 #define ELF_MAXPAGESIZE 0x1000
1834 #define elf_info_to_howto elf_i386_info_to_howto
1835 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1836 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1837 #define bfd_elf32_bfd_is_local_label_name \
1838 elf_i386_is_local_label_name
1839 #define elf_backend_create_dynamic_sections \
1840 _bfd_elf_create_dynamic_sections
1841 #define bfd_elf32_bfd_link_hash_table_create \
1842 elf_i386_link_hash_table_create
1843 #define elf_backend_check_relocs elf_i386_check_relocs
1844 #define elf_backend_adjust_dynamic_symbol \
1845 elf_i386_adjust_dynamic_symbol
1846 #define elf_backend_size_dynamic_sections \
1847 elf_i386_size_dynamic_sections
1848 #define elf_backend_relocate_section elf_i386_relocate_section
1849 #define elf_backend_finish_dynamic_symbol \
1850 elf_i386_finish_dynamic_symbol
1851 #define elf_backend_finish_dynamic_sections \
1852 elf_i386_finish_dynamic_sections
1853 #define elf_backend_want_got_plt 1
1854 #define elf_backend_plt_readonly 1
1855 #define elf_backend_want_plt_sym 0
1857 #include "elf32-target.h"