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 which is in memory at run time, then
970 we probably need a DT_TEXTREL entry. The entries
971 in the .rel.plt section really apply to the
972 .got section, which we created ourselves and so
973 know is not readonly. */
974 outname = bfd_get_section_name (output_bfd,
976 target = bfd_get_section_by_name (output_bfd, outname + 4);
978 && (target->flags & SEC_READONLY) != 0
979 && (target->flags & SEC_ALLOC) != 0)
983 /* We use the reloc_count field as a counter if we need
984 to copy relocs into the output file. */
988 else if (strncmp (name, ".got", 4) != 0)
990 /* It's not one of our sections, so don't allocate space. */
998 for (spp = &s->output_section->owner->sections;
999 *spp != s->output_section;
1000 spp = &(*spp)->next)
1002 *spp = s->output_section->next;
1003 --s->output_section->owner->section_count;
1008 /* Allocate memory for the section contents. */
1009 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1010 if (s->contents == NULL && s->_raw_size != 0)
1014 if (elf_hash_table (info)->dynamic_sections_created)
1016 /* Add some entries to the .dynamic section. We fill in the
1017 values later, in elf_i386_finish_dynamic_sections, but we
1018 must add the entries now so that we get the correct size for
1019 the .dynamic section. The DT_DEBUG entry is filled in by the
1020 dynamic linker and used by the debugger. */
1023 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1029 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1030 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1031 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1032 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1038 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1039 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1040 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1041 sizeof (Elf32_External_Rel)))
1047 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1055 /* This function is called via elf_i386_link_hash_traverse if we are
1056 creating a shared object with -Bsymbolic. It discards the space
1057 allocated to copy PC relative relocs against symbols which are
1058 defined in regular objects. We allocated space for them in the
1059 check_relocs routine, but we won't fill them in in the
1060 relocate_section routine. */
1064 elf_i386_discard_copies (h, ignore)
1065 struct elf_i386_link_hash_entry *h;
1068 struct elf_i386_pcrel_relocs_copied *s;
1070 /* We only discard relocs for symbols defined in a regular object. */
1071 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1074 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1075 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1080 /* Relocate an i386 ELF section. */
1083 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1084 contents, relocs, local_syms, local_sections)
1086 struct bfd_link_info *info;
1088 asection *input_section;
1090 Elf_Internal_Rela *relocs;
1091 Elf_Internal_Sym *local_syms;
1092 asection **local_sections;
1095 Elf_Internal_Shdr *symtab_hdr;
1096 struct elf_link_hash_entry **sym_hashes;
1097 bfd_vma *local_got_offsets;
1101 Elf_Internal_Rela *rel;
1102 Elf_Internal_Rela *relend;
1104 dynobj = elf_hash_table (info)->dynobj;
1105 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1106 sym_hashes = elf_sym_hashes (input_bfd);
1107 local_got_offsets = elf_local_got_offsets (input_bfd);
1114 relend = relocs + input_section->reloc_count;
1115 for (; rel < relend; rel++)
1118 reloc_howto_type *howto;
1119 unsigned long r_symndx;
1120 struct elf_link_hash_entry *h;
1121 Elf_Internal_Sym *sym;
1124 bfd_reloc_status_type r;
1126 r_type = ELF32_R_TYPE (rel->r_info);
1128 || r_type >= (int) R_386_max
1129 || (r_type >= (int) FIRST_INVALID_RELOC
1130 && r_type <= (int) LAST_INVALID_RELOC))
1132 bfd_set_error (bfd_error_bad_value);
1135 howto = elf_howto_table + r_type;
1137 r_symndx = ELF32_R_SYM (rel->r_info);
1139 if (info->relocateable)
1141 /* This is a relocateable link. We don't have to change
1142 anything, unless the reloc is against a section symbol,
1143 in which case we have to adjust according to where the
1144 section symbol winds up in the output section. */
1145 if (r_symndx < symtab_hdr->sh_info)
1147 sym = local_syms + r_symndx;
1148 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1152 sec = local_sections[r_symndx];
1153 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1154 val += sec->output_offset + sym->st_value;
1155 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1162 /* This is a final link. */
1166 if (r_symndx < symtab_hdr->sh_info)
1168 sym = local_syms + r_symndx;
1169 sec = local_sections[r_symndx];
1170 relocation = (sec->output_section->vma
1171 + sec->output_offset
1176 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1177 while (h->root.type == bfd_link_hash_indirect
1178 || h->root.type == bfd_link_hash_warning)
1179 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1180 if (h->root.type == bfd_link_hash_defined
1181 || h->root.type == bfd_link_hash_defweak)
1183 sec = h->root.u.def.section;
1184 if (r_type == R_386_GOTPC
1185 || (r_type == R_386_PLT32
1186 && h->plt_offset != (bfd_vma) -1)
1187 || (r_type == R_386_GOT32
1188 && elf_hash_table (info)->dynamic_sections_created
1190 || (! info->symbolic && h->dynindx != -1)
1191 || (h->elf_link_hash_flags
1192 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1194 && ((! info->symbolic && h->dynindx != -1)
1195 || (h->elf_link_hash_flags
1196 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1197 && (r_type == R_386_32
1198 || r_type == R_386_PC32)
1199 && (input_section->flags & SEC_ALLOC) != 0))
1201 /* In these cases, we don't need the relocation
1202 value. We check specially because in some
1203 obscure cases sec->output_section will be NULL. */
1206 else if (sec->output_section == NULL)
1208 (*_bfd_error_handler)
1209 ("%s: warning: unresolvable relocation against symbol `%s' from %s section",
1210 bfd_get_filename (input_bfd), h->root.root.string,
1211 bfd_get_section_name (input_bfd, input_section));
1215 relocation = (h->root.u.def.value
1216 + sec->output_section->vma
1217 + sec->output_offset);
1219 else if (h->root.type == bfd_link_hash_undefweak)
1221 else if (info->shared && !info->symbolic)
1225 if (! ((*info->callbacks->undefined_symbol)
1226 (info, h->root.root.string, input_bfd,
1227 input_section, rel->r_offset)))
1236 /* Relocation is to the entry for this symbol in the global
1240 sgot = bfd_get_section_by_name (dynobj, ".got");
1241 BFD_ASSERT (sgot != NULL);
1248 off = h->got_offset;
1249 BFD_ASSERT (off != (bfd_vma) -1);
1251 if (! elf_hash_table (info)->dynamic_sections_created
1253 && (info->symbolic || h->dynindx == -1)
1254 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1256 /* This is actually a static link, or it is a
1257 -Bsymbolic link and the symbol is defined
1258 locally, or the symbol was forced to be local
1259 because of a version file. We must initialize
1260 this entry in the global offset table. Since the
1261 offset must always be a multiple of 4, we use the
1262 least significant bit to record whether we have
1263 initialized it already.
1265 When doing a dynamic link, we create a .rel.got
1266 relocation entry to initialize the value. This
1267 is done in the finish_dynamic_symbol routine. */
1272 bfd_put_32 (output_bfd, relocation,
1273 sgot->contents + off);
1278 relocation = sgot->output_offset + off;
1284 BFD_ASSERT (local_got_offsets != NULL
1285 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1287 off = local_got_offsets[r_symndx];
1289 /* The offset must always be a multiple of 4. We use
1290 the least significant bit to record whether we have
1291 already generated the necessary reloc. */
1296 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1301 Elf_Internal_Rel outrel;
1303 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1304 BFD_ASSERT (srelgot != NULL);
1306 outrel.r_offset = (sgot->output_section->vma
1307 + sgot->output_offset
1309 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1310 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1311 (((Elf32_External_Rel *)
1313 + srelgot->reloc_count));
1314 ++srelgot->reloc_count;
1317 local_got_offsets[r_symndx] |= 1;
1320 relocation = sgot->output_offset + off;
1326 /* Relocation is relative to the start of the global offset
1331 sgot = bfd_get_section_by_name (dynobj, ".got");
1332 BFD_ASSERT (sgot != NULL);
1335 /* Note that sgot->output_offset is not involved in this
1336 calculation. We always want the start of .got. If we
1337 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1338 permitted by the ABI, we might have to change this
1340 relocation -= sgot->output_section->vma;
1345 /* Use global offset table as symbol value. */
1349 sgot = bfd_get_section_by_name (dynobj, ".got");
1350 BFD_ASSERT (sgot != NULL);
1353 relocation = sgot->output_section->vma;
1358 /* Relocation is to the entry for this symbol in the
1359 procedure linkage table. */
1361 /* Resolve a PLT32 reloc again a local symbol directly,
1362 without using the procedure linkage table. */
1366 if (h->plt_offset == (bfd_vma) -1)
1368 /* We didn't make a PLT entry for this symbol. This
1369 happens when statically linking PIC code, or when
1370 using -Bsymbolic. */
1376 splt = bfd_get_section_by_name (dynobj, ".plt");
1377 BFD_ASSERT (splt != NULL);
1380 relocation = (splt->output_section->vma
1381 + splt->output_offset
1389 && (r_type != R_386_PC32
1392 && (! info->symbolic
1393 || (h->elf_link_hash_flags
1394 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1396 Elf_Internal_Rel outrel;
1397 boolean skip, relocate;
1399 /* When generating a shared object, these relocations
1400 are copied into the output file to be resolved at run
1407 name = (bfd_elf_string_from_elf_section
1409 elf_elfheader (input_bfd)->e_shstrndx,
1410 elf_section_data (input_section)->rel_hdr.sh_name));
1414 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1415 && strcmp (bfd_get_section_name (input_bfd,
1419 sreloc = bfd_get_section_by_name (dynobj, name);
1420 BFD_ASSERT (sreloc != NULL);
1425 if (elf_section_data (input_section)->stab_info == NULL)
1426 outrel.r_offset = rel->r_offset;
1431 off = (_bfd_stab_section_offset
1432 (output_bfd, &elf_hash_table (info)->stab_info,
1434 &elf_section_data (input_section)->stab_info,
1436 if (off == (bfd_vma) -1)
1438 outrel.r_offset = off;
1441 outrel.r_offset += (input_section->output_section->vma
1442 + input_section->output_offset);
1446 memset (&outrel, 0, sizeof outrel);
1449 else if (r_type == R_386_PC32)
1451 BFD_ASSERT (h != NULL && h->dynindx != -1);
1452 if ((input_section->flags & SEC_ALLOC) != 0)
1456 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1460 /* h->dynindx may be -1 if this symbol was marked to
1463 || ((info->symbolic || h->dynindx == -1)
1464 && (h->elf_link_hash_flags
1465 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1468 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1472 BFD_ASSERT (h->dynindx != -1);
1473 if ((input_section->flags & SEC_ALLOC) != 0)
1477 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1481 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1482 (((Elf32_External_Rel *)
1484 + sreloc->reloc_count));
1485 ++sreloc->reloc_count;
1487 /* If this reloc is against an external symbol, we do
1488 not want to fiddle with the addend. Otherwise, we
1489 need to include the symbol value so that it becomes
1490 an addend for the dynamic reloc. */
1501 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1502 contents, rel->r_offset,
1503 relocation, (bfd_vma) 0);
1505 if (r != bfd_reloc_ok)
1510 case bfd_reloc_outofrange:
1512 case bfd_reloc_overflow:
1517 name = h->root.root.string;
1520 name = bfd_elf_string_from_elf_section (input_bfd,
1521 symtab_hdr->sh_link,
1526 name = bfd_section_name (input_bfd, sec);
1528 if (! ((*info->callbacks->reloc_overflow)
1529 (info, name, howto->name, (bfd_vma) 0,
1530 input_bfd, input_section, rel->r_offset)))
1541 /* Finish up dynamic symbol handling. We set the contents of various
1542 dynamic sections here. */
1545 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1547 struct bfd_link_info *info;
1548 struct elf_link_hash_entry *h;
1549 Elf_Internal_Sym *sym;
1553 dynobj = elf_hash_table (info)->dynobj;
1555 if (h->plt_offset != (bfd_vma) -1)
1562 Elf_Internal_Rel rel;
1564 /* This symbol has an entry in the procedure linkage table. Set
1567 BFD_ASSERT (h->dynindx != -1);
1569 splt = bfd_get_section_by_name (dynobj, ".plt");
1570 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1571 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1572 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1574 /* Get the index in the procedure linkage table which
1575 corresponds to this symbol. This is the index of this symbol
1576 in all the symbols for which we are making plt entries. The
1577 first entry in the procedure linkage table is reserved. */
1578 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1;
1580 /* Get the offset into the .got table of the entry that
1581 corresponds to this function. Each .got entry is 4 bytes.
1582 The first three are reserved. */
1583 got_offset = (plt_index + 3) * 4;
1585 /* Fill in the entry in the procedure linkage table. */
1588 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry,
1590 bfd_put_32 (output_bfd,
1591 (sgot->output_section->vma
1592 + sgot->output_offset
1594 splt->contents + h->plt_offset + 2);
1598 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry,
1600 bfd_put_32 (output_bfd, got_offset,
1601 splt->contents + h->plt_offset + 2);
1604 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1605 splt->contents + h->plt_offset + 7);
1606 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE),
1607 splt->contents + h->plt_offset + 12);
1609 /* Fill in the entry in the global offset table. */
1610 bfd_put_32 (output_bfd,
1611 (splt->output_section->vma
1612 + splt->output_offset
1615 sgot->contents + got_offset);
1617 /* Fill in the entry in the .rel.plt section. */
1618 rel.r_offset = (sgot->output_section->vma
1619 + sgot->output_offset
1621 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1622 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1623 ((Elf32_External_Rel *) srel->contents
1626 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1628 /* Mark the symbol as undefined, rather than as defined in
1629 the .plt section. Leave the value alone. */
1630 sym->st_shndx = SHN_UNDEF;
1634 if (h->got_offset != (bfd_vma) -1)
1638 Elf_Internal_Rel rel;
1640 /* This symbol has an entry in the global offset table. Set it
1643 sgot = bfd_get_section_by_name (dynobj, ".got");
1644 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1645 BFD_ASSERT (sgot != NULL && srel != NULL);
1647 rel.r_offset = (sgot->output_section->vma
1648 + sgot->output_offset
1649 + (h->got_offset &~ 1));
1651 /* If this is a -Bsymbolic link, and the symbol is defined
1652 locally, we just want to emit a RELATIVE reloc. Likewise if
1653 the symbol was forced to be local because of a version file.
1654 The entry in the global offset table will already have been
1655 initialized in the relocate_section function. */
1657 && (info->symbolic || h->dynindx == -1)
1658 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1659 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1662 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1663 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1666 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1667 ((Elf32_External_Rel *) srel->contents
1668 + srel->reloc_count));
1669 ++srel->reloc_count;
1672 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1675 Elf_Internal_Rel rel;
1677 /* This symbol needs a copy reloc. Set it up. */
1679 BFD_ASSERT (h->dynindx != -1
1680 && (h->root.type == bfd_link_hash_defined
1681 || h->root.type == bfd_link_hash_defweak));
1683 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1685 BFD_ASSERT (s != NULL);
1687 rel.r_offset = (h->root.u.def.value
1688 + h->root.u.def.section->output_section->vma
1689 + h->root.u.def.section->output_offset);
1690 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1691 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1692 ((Elf32_External_Rel *) s->contents
1697 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1698 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1699 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1700 sym->st_shndx = SHN_ABS;
1705 /* Finish up the dynamic sections. */
1708 elf_i386_finish_dynamic_sections (output_bfd, info)
1710 struct bfd_link_info *info;
1716 dynobj = elf_hash_table (info)->dynobj;
1718 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1719 BFD_ASSERT (sgot != NULL);
1720 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1722 if (elf_hash_table (info)->dynamic_sections_created)
1725 Elf32_External_Dyn *dyncon, *dynconend;
1727 splt = bfd_get_section_by_name (dynobj, ".plt");
1728 BFD_ASSERT (splt != NULL && sdyn != NULL);
1730 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1731 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1732 for (; dyncon < dynconend; dyncon++)
1734 Elf_Internal_Dyn dyn;
1738 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1751 s = bfd_get_section_by_name (output_bfd, name);
1752 BFD_ASSERT (s != NULL);
1753 dyn.d_un.d_ptr = s->vma;
1754 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1758 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1759 BFD_ASSERT (s != NULL);
1760 if (s->_cooked_size != 0)
1761 dyn.d_un.d_val = s->_cooked_size;
1763 dyn.d_un.d_val = s->_raw_size;
1764 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1768 /* My reading of the SVR4 ABI indicates that the
1769 procedure linkage table relocs (DT_JMPREL) should be
1770 included in the overall relocs (DT_REL). This is
1771 what Solaris does. However, UnixWare can not handle
1772 that case. Therefore, we override the DT_RELSZ entry
1773 here to make it not include the JMPREL relocs. Since
1774 the linker script arranges for .rel.plt to follow all
1775 other relocation sections, we don't have to worry
1776 about changing the DT_REL entry. */
1777 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1780 if (s->_cooked_size != 0)
1781 dyn.d_un.d_val -= s->_cooked_size;
1783 dyn.d_un.d_val -= s->_raw_size;
1785 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1790 /* Fill in the first entry in the procedure linkage table. */
1791 if (splt->_raw_size > 0)
1794 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1797 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1798 bfd_put_32 (output_bfd,
1799 sgot->output_section->vma + sgot->output_offset + 4,
1800 splt->contents + 2);
1801 bfd_put_32 (output_bfd,
1802 sgot->output_section->vma + sgot->output_offset + 8,
1803 splt->contents + 8);
1807 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1808 really seem like the right value. */
1809 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1812 /* Fill in the first three entries in the global offset table. */
1813 if (sgot->_raw_size > 0)
1816 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1818 bfd_put_32 (output_bfd,
1819 sdyn->output_section->vma + sdyn->output_offset,
1821 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1822 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1825 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1830 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1831 #define TARGET_LITTLE_NAME "elf32-i386"
1832 #define ELF_ARCH bfd_arch_i386
1833 #define ELF_MACHINE_CODE EM_386
1834 #define ELF_MAXPAGESIZE 0x1000
1835 #define elf_info_to_howto elf_i386_info_to_howto
1836 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1837 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1838 #define bfd_elf32_bfd_is_local_label_name \
1839 elf_i386_is_local_label_name
1840 #define elf_backend_create_dynamic_sections \
1841 _bfd_elf_create_dynamic_sections
1842 #define bfd_elf32_bfd_link_hash_table_create \
1843 elf_i386_link_hash_table_create
1844 #define elf_backend_check_relocs elf_i386_check_relocs
1845 #define elf_backend_adjust_dynamic_symbol \
1846 elf_i386_adjust_dynamic_symbol
1847 #define elf_backend_size_dynamic_sections \
1848 elf_i386_size_dynamic_sections
1849 #define elf_backend_relocate_section elf_i386_relocate_section
1850 #define elf_backend_finish_dynamic_symbol \
1851 elf_i386_finish_dynamic_symbol
1852 #define elf_backend_finish_dynamic_sections \
1853 elf_i386_finish_dynamic_sections
1854 #define elf_backend_want_got_plt 1
1855 #define elf_backend_plt_readonly 1
1856 #define elf_backend_want_plt_sym 0
1858 #include "elf32-target.h"