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 #define ELF_DYNAMIC_INTERPRETER "/usr/libexec/ld-elf.so.1"
256 /* The size in bytes of an entry in the procedure linkage table. */
258 #define PLT_ENTRY_SIZE 16
260 /* The first entry in an absolute procedure linkage table looks like
261 this. See the SVR4 ABI i386 supplement to see how this works. */
263 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
265 0xff, 0x35, /* pushl contents of address */
266 0, 0, 0, 0, /* replaced with address of .got + 4. */
267 0xff, 0x25, /* jmp indirect */
268 0, 0, 0, 0, /* replaced with address of .got + 8. */
269 0, 0, 0, 0 /* pad out to 16 bytes. */
272 /* Subsequent entries in an absolute procedure linkage table look like
275 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
277 0xff, 0x25, /* jmp indirect */
278 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
279 0x68, /* pushl immediate */
280 0, 0, 0, 0, /* replaced with offset into relocation table. */
281 0xe9, /* jmp relative */
282 0, 0, 0, 0 /* replaced with offset to start of .plt. */
285 /* The first entry in a PIC procedure linkage table look like this. */
287 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
289 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
290 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
291 0, 0, 0, 0 /* pad out to 16 bytes. */
294 /* Subsequent entries in a PIC procedure linkage table look like this. */
296 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
298 0xff, 0xa3, /* jmp *offset(%ebx) */
299 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
300 0x68, /* pushl immediate */
301 0, 0, 0, 0, /* replaced with offset into relocation table. */
302 0xe9, /* jmp relative */
303 0, 0, 0, 0 /* replaced with offset to start of .plt. */
306 /* The i386 linker needs to keep track of the number of relocs that it
307 decides to copy in check_relocs for each symbol. This is so that
308 it can discard PC relative relocs if it doesn't need them when
309 linking with -Bsymbolic. We store the information in a field
310 extending the regular ELF linker hash table. */
312 /* This structure keeps track of the number of PC relative relocs we
313 have copied for a given symbol. */
315 struct elf_i386_pcrel_relocs_copied
318 struct elf_i386_pcrel_relocs_copied *next;
319 /* A section in dynobj. */
321 /* Number of relocs copied in this section. */
325 /* i386 ELF linker hash entry. */
327 struct elf_i386_link_hash_entry
329 struct elf_link_hash_entry root;
331 /* Number of PC relative relocs copied for this symbol. */
332 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
335 /* i386 ELF linker hash table. */
337 struct elf_i386_link_hash_table
339 struct elf_link_hash_table root;
342 /* Declare this now that the above structures are defined. */
344 static boolean elf_i386_discard_copies
345 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
347 /* Traverse an i386 ELF linker hash table. */
349 #define elf_i386_link_hash_traverse(table, func, info) \
350 (elf_link_hash_traverse \
352 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
355 /* Get the i386 ELF linker hash table from a link_info structure. */
357 #define elf_i386_hash_table(p) \
358 ((struct elf_i386_link_hash_table *) ((p)->hash))
360 /* Create an entry in an i386 ELF linker hash table. */
362 static struct bfd_hash_entry *
363 elf_i386_link_hash_newfunc (entry, table, string)
364 struct bfd_hash_entry *entry;
365 struct bfd_hash_table *table;
368 struct elf_i386_link_hash_entry *ret =
369 (struct elf_i386_link_hash_entry *) entry;
371 /* Allocate the structure if it has not already been allocated by a
373 if (ret == (struct elf_i386_link_hash_entry *) NULL)
374 ret = ((struct elf_i386_link_hash_entry *)
375 bfd_hash_allocate (table,
376 sizeof (struct elf_i386_link_hash_entry)));
377 if (ret == (struct elf_i386_link_hash_entry *) NULL)
378 return (struct bfd_hash_entry *) ret;
380 /* Call the allocation method of the superclass. */
381 ret = ((struct elf_i386_link_hash_entry *)
382 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
384 if (ret != (struct elf_i386_link_hash_entry *) NULL)
386 ret->pcrel_relocs_copied = NULL;
389 return (struct bfd_hash_entry *) ret;
392 /* Create an i386 ELF linker hash table. */
394 static struct bfd_link_hash_table *
395 elf_i386_link_hash_table_create (abfd)
398 struct elf_i386_link_hash_table *ret;
400 ret = ((struct elf_i386_link_hash_table *)
401 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
402 if (ret == (struct elf_i386_link_hash_table *) NULL)
405 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
406 elf_i386_link_hash_newfunc))
408 bfd_release (abfd, ret);
412 return &ret->root.root;
415 /* Look through the relocs for a section during the first phase, and
416 allocate space in the global offset table or procedure linkage
420 elf_i386_check_relocs (abfd, info, sec, relocs)
422 struct bfd_link_info *info;
424 const Elf_Internal_Rela *relocs;
427 Elf_Internal_Shdr *symtab_hdr;
428 struct elf_link_hash_entry **sym_hashes;
429 bfd_vma *local_got_offsets;
430 const Elf_Internal_Rela *rel;
431 const Elf_Internal_Rela *rel_end;
436 if (info->relocateable)
439 dynobj = elf_hash_table (info)->dynobj;
440 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
441 sym_hashes = elf_sym_hashes (abfd);
442 local_got_offsets = elf_local_got_offsets (abfd);
448 rel_end = relocs + sec->reloc_count;
449 for (rel = relocs; rel < rel_end; rel++)
451 unsigned long r_symndx;
452 struct elf_link_hash_entry *h;
454 r_symndx = ELF32_R_SYM (rel->r_info);
456 if (r_symndx < symtab_hdr->sh_info)
459 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
461 /* Some relocs require a global offset table. */
464 switch (ELF32_R_TYPE (rel->r_info))
469 elf_hash_table (info)->dynobj = dynobj = abfd;
470 if (! _bfd_elf_create_got_section (dynobj, info))
479 switch (ELF32_R_TYPE (rel->r_info))
482 /* This symbol requires a global offset table entry. */
486 sgot = bfd_get_section_by_name (dynobj, ".got");
487 BFD_ASSERT (sgot != NULL);
491 && (h != NULL || info->shared))
493 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
496 srelgot = bfd_make_section (dynobj, ".rel.got");
498 || ! bfd_set_section_flags (dynobj, srelgot,
505 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
512 if (h->got_offset != (bfd_vma) -1)
514 /* We have already allocated space in the .got. */
517 h->got_offset = sgot->_raw_size;
519 /* Make sure this symbol is output as a dynamic symbol. */
520 if (h->dynindx == -1)
522 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
526 srelgot->_raw_size += sizeof (Elf32_External_Rel);
530 /* This is a global offset table entry for a local
532 if (local_got_offsets == NULL)
535 register unsigned int i;
537 size = symtab_hdr->sh_info * sizeof (bfd_vma);
538 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
539 if (local_got_offsets == NULL)
541 elf_local_got_offsets (abfd) = local_got_offsets;
542 for (i = 0; i < symtab_hdr->sh_info; i++)
543 local_got_offsets[i] = (bfd_vma) -1;
545 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
547 /* We have already allocated space in the .got. */
550 local_got_offsets[r_symndx] = sgot->_raw_size;
554 /* If we are generating a shared object, we need to
555 output a R_386_RELATIVE reloc so that the dynamic
556 linker can adjust this GOT entry. */
557 srelgot->_raw_size += sizeof (Elf32_External_Rel);
561 sgot->_raw_size += 4;
566 /* This symbol requires a procedure linkage table entry. We
567 actually build the entry in adjust_dynamic_symbol,
568 because this might be a case of linking PIC code which is
569 never referenced by a dynamic object, in which case we
570 don't need to generate a procedure linkage table entry
573 /* If this is a local symbol, we resolve it directly without
574 creating a procedure linkage table entry. */
578 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
584 /* If we are creating a shared library, and this is a reloc
585 against a global symbol, or a non PC relative reloc
586 against a local symbol, then we need to copy the reloc
587 into the shared library. However, if we are linking with
588 -Bsymbolic, we do not need to copy a reloc against a
589 global symbol which is defined in an object we are
590 including in the link (i.e., DEF_REGULAR is set). At
591 this point we have not seen all the input files, so it is
592 possible that DEF_REGULAR is not set now but will be set
593 later (it is never cleared). We account for that
594 possibility below by storing information in the
595 pcrel_relocs_copied field of the hash table entry. */
597 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
600 || (h->elf_link_hash_flags
601 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
603 /* When creating a shared object, we must copy these
604 reloc types into the output file. We create a reloc
605 section in dynobj and make room for this reloc. */
610 name = (bfd_elf_string_from_elf_section
612 elf_elfheader (abfd)->e_shstrndx,
613 elf_section_data (sec)->rel_hdr.sh_name));
617 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
618 && strcmp (bfd_get_section_name (abfd, sec),
621 sreloc = bfd_get_section_by_name (dynobj, name);
626 sreloc = bfd_make_section (dynobj, name);
627 flags = (SEC_HAS_CONTENTS | SEC_READONLY
628 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
629 if ((sec->flags & SEC_ALLOC) != 0)
630 flags |= SEC_ALLOC | SEC_LOAD;
632 || ! bfd_set_section_flags (dynobj, sreloc, flags)
633 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
638 sreloc->_raw_size += sizeof (Elf32_External_Rel);
640 /* If we are linking with -Bsymbolic, and this is a
641 global symbol, we count the number of PC relative
642 relocations we have entered for this symbol, so that
643 we can discard them again if the symbol is later
644 defined by a regular object. Note that this function
645 is only called if we are using an elf_i386 linker
646 hash table, which means that h is really a pointer to
647 an elf_i386_link_hash_entry. */
648 if (h != NULL && info->symbolic
649 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
651 struct elf_i386_link_hash_entry *eh;
652 struct elf_i386_pcrel_relocs_copied *p;
654 eh = (struct elf_i386_link_hash_entry *) h;
656 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
657 if (p->section == sreloc)
662 p = ((struct elf_i386_pcrel_relocs_copied *)
663 bfd_alloc (dynobj, sizeof *p));
666 p->next = eh->pcrel_relocs_copied;
667 eh->pcrel_relocs_copied = p;
686 /* Adjust a symbol defined by a dynamic object and referenced by a
687 regular object. The current definition is in some section of the
688 dynamic object, but we're not including those sections. We have to
689 change the definition to something the rest of the link can
693 elf_i386_adjust_dynamic_symbol (info, h)
694 struct bfd_link_info *info;
695 struct elf_link_hash_entry *h;
699 unsigned int power_of_two;
701 dynobj = elf_hash_table (info)->dynobj;
703 /* Make sure we know what is going on here. */
704 BFD_ASSERT (dynobj != NULL
705 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
706 || h->weakdef != NULL
707 || ((h->elf_link_hash_flags
708 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
709 && (h->elf_link_hash_flags
710 & ELF_LINK_HASH_REF_REGULAR) != 0
711 && (h->elf_link_hash_flags
712 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
714 /* If this is a function, put it in the procedure linkage table. We
715 will fill in the contents of the procedure linkage table later,
716 when we know the address of the .got section. */
717 if (h->type == STT_FUNC
718 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
721 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
722 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
724 /* This case can occur if we saw a PLT32 reloc in an input
725 file, but the symbol was never referred to by a dynamic
726 object. In such a case, we don't actually need to build
727 a procedure linkage table, and we can just do a PC32
729 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
733 /* Make sure this symbol is output as a dynamic symbol. */
734 if (h->dynindx == -1)
736 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
740 s = bfd_get_section_by_name (dynobj, ".plt");
741 BFD_ASSERT (s != NULL);
743 /* If this is the first .plt entry, make room for the special
745 if (s->_raw_size == 0)
746 s->_raw_size += PLT_ENTRY_SIZE;
748 /* If this symbol is not defined in a regular file, and we are
749 not generating a shared library, then set the symbol to this
750 location in the .plt. This is required to make function
751 pointers compare as equal between the normal executable and
752 the shared library. */
754 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
756 h->root.u.def.section = s;
757 h->root.u.def.value = s->_raw_size;
760 h->plt_offset = s->_raw_size;
762 /* Make room for this entry. */
763 s->_raw_size += PLT_ENTRY_SIZE;
765 /* We also need to make an entry in the .got.plt section, which
766 will be placed in the .got section by the linker script. */
768 s = bfd_get_section_by_name (dynobj, ".got.plt");
769 BFD_ASSERT (s != NULL);
772 /* We also need to make an entry in the .rel.plt section. */
774 s = bfd_get_section_by_name (dynobj, ".rel.plt");
775 BFD_ASSERT (s != NULL);
776 s->_raw_size += sizeof (Elf32_External_Rel);
781 /* If this is a weak symbol, and there is a real definition, the
782 processor independent code will have arranged for us to see the
783 real definition first, and we can just use the same value. */
784 if (h->weakdef != NULL)
786 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
787 || h->weakdef->root.type == bfd_link_hash_defweak);
788 h->root.u.def.section = h->weakdef->root.u.def.section;
789 h->root.u.def.value = h->weakdef->root.u.def.value;
793 /* This is a reference to a symbol defined by a dynamic object which
794 is not a function. */
796 /* If we are creating a shared library, we must presume that the
797 only references to the symbol are via the global offset table.
798 For such cases we need not do anything here; the relocations will
799 be handled correctly by relocate_section. */
803 /* We must allocate the symbol in our .dynbss section, which will
804 become part of the .bss section of the executable. There will be
805 an entry for this symbol in the .dynsym section. The dynamic
806 object will contain position independent code, so all references
807 from the dynamic object to this symbol will go through the global
808 offset table. The dynamic linker will use the .dynsym entry to
809 determine the address it must put in the global offset table, so
810 both the dynamic object and the regular object will refer to the
811 same memory location for the variable. */
813 s = bfd_get_section_by_name (dynobj, ".dynbss");
814 BFD_ASSERT (s != NULL);
816 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
817 copy the initial value out of the dynamic object and into the
818 runtime process image. We need to remember the offset into the
819 .rel.bss section we are going to use. */
820 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
824 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
825 BFD_ASSERT (srel != NULL);
826 srel->_raw_size += sizeof (Elf32_External_Rel);
827 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
830 /* We need to figure out the alignment required for this symbol. I
831 have no idea how ELF linkers handle this. */
832 power_of_two = bfd_log2 (h->size);
833 if (power_of_two > 3)
836 /* Apply the required alignment. */
837 s->_raw_size = BFD_ALIGN (s->_raw_size,
838 (bfd_size_type) (1 << power_of_two));
839 if (power_of_two > bfd_get_section_alignment (dynobj, s))
841 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
845 /* Define the symbol as being at this point in the section. */
846 h->root.u.def.section = s;
847 h->root.u.def.value = s->_raw_size;
849 /* Increment the section size to make room for the symbol. */
850 s->_raw_size += h->size;
855 /* Set the sizes of the dynamic sections. */
858 elf_i386_size_dynamic_sections (output_bfd, info)
860 struct bfd_link_info *info;
868 dynobj = elf_hash_table (info)->dynobj;
869 BFD_ASSERT (dynobj != NULL);
871 if (elf_hash_table (info)->dynamic_sections_created)
873 /* Set the contents of the .interp section to the interpreter. */
876 s = bfd_get_section_by_name (dynobj, ".interp");
877 BFD_ASSERT (s != NULL);
878 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
879 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
884 /* We may have created entries in the .rel.got section.
885 However, if we are not creating the dynamic sections, we will
886 not actually use these entries. Reset the size of .rel.got,
887 which will cause it to get stripped from the output file
889 s = bfd_get_section_by_name (dynobj, ".rel.got");
894 /* If this is a -Bsymbolic shared link, then we need to discard all
895 PC relative relocs against symbols defined in a regular object.
896 We allocated space for them in the check_relocs routine, but we
897 will not fill them in in the relocate_section routine. */
898 if (info->shared && info->symbolic)
899 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
900 elf_i386_discard_copies,
903 /* The check_relocs and adjust_dynamic_symbol entry points have
904 determined the sizes of the various dynamic sections. Allocate
909 for (s = dynobj->sections; s != NULL; s = s->next)
914 if ((s->flags & SEC_LINKER_CREATED) == 0)
917 /* It's OK to base decisions on the section name, because none
918 of the dynobj section names depend upon the input files. */
919 name = bfd_get_section_name (dynobj, s);
923 if (strcmp (name, ".plt") == 0)
925 if (s->_raw_size == 0)
927 /* Strip this section if we don't need it; see the
933 /* Remember whether there is a PLT. */
937 else if (strncmp (name, ".rel", 4) == 0)
939 if (s->_raw_size == 0)
941 /* If we don't need this section, strip it from the
942 output file. This is mostly to handle .rel.bss and
943 .rel.plt. We must create both sections in
944 create_dynamic_sections, because they must be created
945 before the linker maps input sections to output
946 sections. The linker does that before
947 adjust_dynamic_symbol is called, and it is that
948 function which decides whether anything needs to go
949 into these sections. */
956 /* Remember whether there are any reloc sections other
958 if (strcmp (name, ".rel.plt") != 0)
964 /* If this relocation section applies to a read only
965 section which is in memory at run time, then
966 we probably need a DT_TEXTREL entry. The entries
967 in the .rel.plt section really apply to the
968 .got section, which we created ourselves and so
969 know is not readonly. */
970 outname = bfd_get_section_name (output_bfd,
972 target = bfd_get_section_by_name (output_bfd, outname + 4);
974 && (target->flags & SEC_READONLY) != 0
975 && (target->flags & SEC_ALLOC) != 0)
979 /* We use the reloc_count field as a counter if we need
980 to copy relocs into the output file. */
984 else if (strncmp (name, ".got", 4) != 0)
986 /* It's not one of our sections, so don't allocate space. */
994 for (spp = &s->output_section->owner->sections;
995 *spp != s->output_section;
998 *spp = s->output_section->next;
999 --s->output_section->owner->section_count;
1004 /* Allocate memory for the section contents. */
1005 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1006 if (s->contents == NULL && s->_raw_size != 0)
1010 if (elf_hash_table (info)->dynamic_sections_created)
1012 /* Add some entries to the .dynamic section. We fill in the
1013 values later, in elf_i386_finish_dynamic_sections, but we
1014 must add the entries now so that we get the correct size for
1015 the .dynamic section. The DT_DEBUG entry is filled in by the
1016 dynamic linker and used by the debugger. */
1019 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1025 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1026 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1027 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1028 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1034 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1035 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1036 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1037 sizeof (Elf32_External_Rel)))
1043 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1051 /* This function is called via elf_i386_link_hash_traverse if we are
1052 creating a shared object with -Bsymbolic. It discards the space
1053 allocated to copy PC relative relocs against symbols which are
1054 defined in regular objects. We allocated space for them in the
1055 check_relocs routine, but we won't fill them in in the
1056 relocate_section routine. */
1060 elf_i386_discard_copies (h, ignore)
1061 struct elf_i386_link_hash_entry *h;
1064 struct elf_i386_pcrel_relocs_copied *s;
1066 /* We only discard relocs for symbols defined in a regular object. */
1067 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1070 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1071 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1076 /* Relocate an i386 ELF section. */
1079 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1080 contents, relocs, local_syms, local_sections)
1082 struct bfd_link_info *info;
1084 asection *input_section;
1086 Elf_Internal_Rela *relocs;
1087 Elf_Internal_Sym *local_syms;
1088 asection **local_sections;
1091 Elf_Internal_Shdr *symtab_hdr;
1092 struct elf_link_hash_entry **sym_hashes;
1093 bfd_vma *local_got_offsets;
1097 Elf_Internal_Rela *rel;
1098 Elf_Internal_Rela *relend;
1100 dynobj = elf_hash_table (info)->dynobj;
1101 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1102 sym_hashes = elf_sym_hashes (input_bfd);
1103 local_got_offsets = elf_local_got_offsets (input_bfd);
1110 relend = relocs + input_section->reloc_count;
1111 for (; rel < relend; rel++)
1114 reloc_howto_type *howto;
1115 unsigned long r_symndx;
1116 struct elf_link_hash_entry *h;
1117 Elf_Internal_Sym *sym;
1120 bfd_reloc_status_type r;
1122 r_type = ELF32_R_TYPE (rel->r_info);
1124 || r_type >= (int) R_386_max
1125 || (r_type >= (int) FIRST_INVALID_RELOC
1126 && r_type <= (int) LAST_INVALID_RELOC))
1128 bfd_set_error (bfd_error_bad_value);
1131 howto = elf_howto_table + r_type;
1133 r_symndx = ELF32_R_SYM (rel->r_info);
1135 if (info->relocateable)
1137 /* This is a relocateable link. We don't have to change
1138 anything, unless the reloc is against a section symbol,
1139 in which case we have to adjust according to where the
1140 section symbol winds up in the output section. */
1141 if (r_symndx < symtab_hdr->sh_info)
1143 sym = local_syms + r_symndx;
1144 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1148 sec = local_sections[r_symndx];
1149 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1150 val += sec->output_offset + sym->st_value;
1151 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1158 /* This is a final link. */
1162 if (r_symndx < symtab_hdr->sh_info)
1164 sym = local_syms + r_symndx;
1165 sec = local_sections[r_symndx];
1166 relocation = (sec->output_section->vma
1167 + sec->output_offset
1172 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1173 while (h->root.type == bfd_link_hash_indirect
1174 || h->root.type == bfd_link_hash_warning)
1175 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1176 if (h->root.type == bfd_link_hash_defined
1177 || h->root.type == bfd_link_hash_defweak)
1179 sec = h->root.u.def.section;
1180 if (r_type == R_386_GOTPC
1181 || (r_type == R_386_PLT32
1182 && h->plt_offset != (bfd_vma) -1)
1183 || (r_type == R_386_GOT32
1184 && elf_hash_table (info)->dynamic_sections_created
1186 || (! info->symbolic && h->dynindx != -1)
1187 || (h->elf_link_hash_flags
1188 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1190 && ((! info->symbolic && h->dynindx != -1)
1191 || (h->elf_link_hash_flags
1192 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1193 && (r_type == R_386_32
1194 || r_type == R_386_PC32)
1195 && (input_section->flags & SEC_ALLOC) != 0))
1197 /* In these cases, we don't need the relocation
1198 value. We check specially because in some
1199 obscure cases sec->output_section will be NULL. */
1202 else if (sec->output_section == NULL)
1204 (*_bfd_error_handler)
1205 ("%s: warning: unresolvable relocation against symbol `%s' from %s section",
1206 bfd_get_filename (input_bfd), h->root.root.string,
1207 bfd_get_section_name (input_bfd, input_section));
1211 relocation = (h->root.u.def.value
1212 + sec->output_section->vma
1213 + sec->output_offset);
1215 else if (h->root.type == bfd_link_hash_undefweak)
1217 else if (info->shared && !info->symbolic)
1221 if (! ((*info->callbacks->undefined_symbol)
1222 (info, h->root.root.string, input_bfd,
1223 input_section, rel->r_offset)))
1232 /* Relocation is to the entry for this symbol in the global
1236 sgot = bfd_get_section_by_name (dynobj, ".got");
1237 BFD_ASSERT (sgot != NULL);
1244 off = h->got_offset;
1245 BFD_ASSERT (off != (bfd_vma) -1);
1247 if (! elf_hash_table (info)->dynamic_sections_created
1249 && (info->symbolic || h->dynindx == -1)
1250 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1252 /* This is actually a static link, or it is a
1253 -Bsymbolic link and the symbol is defined
1254 locally, or the symbol was forced to be local
1255 because of a version file. We must initialize
1256 this entry in the global offset table. Since the
1257 offset must always be a multiple of 4, we use the
1258 least significant bit to record whether we have
1259 initialized it already.
1261 When doing a dynamic link, we create a .rel.got
1262 relocation entry to initialize the value. This
1263 is done in the finish_dynamic_symbol routine. */
1268 bfd_put_32 (output_bfd, relocation,
1269 sgot->contents + off);
1274 relocation = sgot->output_offset + off;
1280 BFD_ASSERT (local_got_offsets != NULL
1281 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1283 off = local_got_offsets[r_symndx];
1285 /* The offset must always be a multiple of 4. We use
1286 the least significant bit to record whether we have
1287 already generated the necessary reloc. */
1292 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1297 Elf_Internal_Rel outrel;
1299 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1300 BFD_ASSERT (srelgot != NULL);
1302 outrel.r_offset = (sgot->output_section->vma
1303 + sgot->output_offset
1305 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1306 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1307 (((Elf32_External_Rel *)
1309 + srelgot->reloc_count));
1310 ++srelgot->reloc_count;
1313 local_got_offsets[r_symndx] |= 1;
1316 relocation = sgot->output_offset + off;
1322 /* Relocation is relative to the start of the global offset
1327 sgot = bfd_get_section_by_name (dynobj, ".got");
1328 BFD_ASSERT (sgot != NULL);
1331 /* Note that sgot->output_offset is not involved in this
1332 calculation. We always want the start of .got. If we
1333 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1334 permitted by the ABI, we might have to change this
1336 relocation -= sgot->output_section->vma;
1341 /* Use global offset table as symbol value. */
1345 sgot = bfd_get_section_by_name (dynobj, ".got");
1346 BFD_ASSERT (sgot != NULL);
1349 relocation = sgot->output_section->vma;
1354 /* Relocation is to the entry for this symbol in the
1355 procedure linkage table. */
1357 /* Resolve a PLT32 reloc again a local symbol directly,
1358 without using the procedure linkage table. */
1362 if (h->plt_offset == (bfd_vma) -1)
1364 /* We didn't make a PLT entry for this symbol. This
1365 happens when statically linking PIC code, or when
1366 using -Bsymbolic. */
1372 splt = bfd_get_section_by_name (dynobj, ".plt");
1373 BFD_ASSERT (splt != NULL);
1376 relocation = (splt->output_section->vma
1377 + splt->output_offset
1385 && (r_type != R_386_PC32
1388 && (! info->symbolic
1389 || (h->elf_link_hash_flags
1390 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1392 Elf_Internal_Rel outrel;
1393 boolean skip, relocate;
1395 /* When generating a shared object, these relocations
1396 are copied into the output file to be resolved at run
1403 name = (bfd_elf_string_from_elf_section
1405 elf_elfheader (input_bfd)->e_shstrndx,
1406 elf_section_data (input_section)->rel_hdr.sh_name));
1410 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1411 && strcmp (bfd_get_section_name (input_bfd,
1415 sreloc = bfd_get_section_by_name (dynobj, name);
1416 BFD_ASSERT (sreloc != NULL);
1421 if (elf_section_data (input_section)->stab_info == NULL)
1422 outrel.r_offset = rel->r_offset;
1427 off = (_bfd_stab_section_offset
1428 (output_bfd, &elf_hash_table (info)->stab_info,
1430 &elf_section_data (input_section)->stab_info,
1432 if (off == (bfd_vma) -1)
1434 outrel.r_offset = off;
1437 outrel.r_offset += (input_section->output_section->vma
1438 + input_section->output_offset);
1442 memset (&outrel, 0, sizeof outrel);
1445 else if (r_type == R_386_PC32)
1447 BFD_ASSERT (h != NULL && h->dynindx != -1);
1448 if ((input_section->flags & SEC_ALLOC) != 0)
1452 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1456 /* h->dynindx may be -1 if this symbol was marked to
1459 || ((info->symbolic || h->dynindx == -1)
1460 && (h->elf_link_hash_flags
1461 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1464 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1468 BFD_ASSERT (h->dynindx != -1);
1469 if ((input_section->flags & SEC_ALLOC) != 0)
1473 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1477 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1478 (((Elf32_External_Rel *)
1480 + sreloc->reloc_count));
1481 ++sreloc->reloc_count;
1483 /* If this reloc is against an external symbol, we do
1484 not want to fiddle with the addend. Otherwise, we
1485 need to include the symbol value so that it becomes
1486 an addend for the dynamic reloc. */
1497 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1498 contents, rel->r_offset,
1499 relocation, (bfd_vma) 0);
1501 if (r != bfd_reloc_ok)
1506 case bfd_reloc_outofrange:
1508 case bfd_reloc_overflow:
1513 name = h->root.root.string;
1516 name = bfd_elf_string_from_elf_section (input_bfd,
1517 symtab_hdr->sh_link,
1522 name = bfd_section_name (input_bfd, sec);
1524 if (! ((*info->callbacks->reloc_overflow)
1525 (info, name, howto->name, (bfd_vma) 0,
1526 input_bfd, input_section, rel->r_offset)))
1537 /* Finish up dynamic symbol handling. We set the contents of various
1538 dynamic sections here. */
1541 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1543 struct bfd_link_info *info;
1544 struct elf_link_hash_entry *h;
1545 Elf_Internal_Sym *sym;
1549 dynobj = elf_hash_table (info)->dynobj;
1551 if (h->plt_offset != (bfd_vma) -1)
1558 Elf_Internal_Rel rel;
1560 /* This symbol has an entry in the procedure linkage table. Set
1563 BFD_ASSERT (h->dynindx != -1);
1565 splt = bfd_get_section_by_name (dynobj, ".plt");
1566 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1567 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1568 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1570 /* Get the index in the procedure linkage table which
1571 corresponds to this symbol. This is the index of this symbol
1572 in all the symbols for which we are making plt entries. The
1573 first entry in the procedure linkage table is reserved. */
1574 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1;
1576 /* Get the offset into the .got table of the entry that
1577 corresponds to this function. Each .got entry is 4 bytes.
1578 The first three are reserved. */
1579 got_offset = (plt_index + 3) * 4;
1581 /* Fill in the entry in the procedure linkage table. */
1584 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry,
1586 bfd_put_32 (output_bfd,
1587 (sgot->output_section->vma
1588 + sgot->output_offset
1590 splt->contents + h->plt_offset + 2);
1594 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry,
1596 bfd_put_32 (output_bfd, got_offset,
1597 splt->contents + h->plt_offset + 2);
1600 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1601 splt->contents + h->plt_offset + 7);
1602 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE),
1603 splt->contents + h->plt_offset + 12);
1605 /* Fill in the entry in the global offset table. */
1606 bfd_put_32 (output_bfd,
1607 (splt->output_section->vma
1608 + splt->output_offset
1611 sgot->contents + got_offset);
1613 /* Fill in the entry in the .rel.plt section. */
1614 rel.r_offset = (sgot->output_section->vma
1615 + sgot->output_offset
1617 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1618 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1619 ((Elf32_External_Rel *) srel->contents
1622 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1624 /* Mark the symbol as undefined, rather than as defined in
1625 the .plt section. Leave the value alone. */
1626 sym->st_shndx = SHN_UNDEF;
1630 if (h->got_offset != (bfd_vma) -1)
1634 Elf_Internal_Rel rel;
1636 /* This symbol has an entry in the global offset table. Set it
1639 sgot = bfd_get_section_by_name (dynobj, ".got");
1640 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1641 BFD_ASSERT (sgot != NULL && srel != NULL);
1643 rel.r_offset = (sgot->output_section->vma
1644 + sgot->output_offset
1645 + (h->got_offset &~ 1));
1647 /* If this is a -Bsymbolic link, and the symbol is defined
1648 locally, we just want to emit a RELATIVE reloc. Likewise if
1649 the symbol was forced to be local because of a version file.
1650 The entry in the global offset table will already have been
1651 initialized in the relocate_section function. */
1653 && (info->symbolic || h->dynindx == -1)
1654 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1655 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1658 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1659 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1662 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1663 ((Elf32_External_Rel *) srel->contents
1664 + srel->reloc_count));
1665 ++srel->reloc_count;
1668 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1671 Elf_Internal_Rel rel;
1673 /* This symbol needs a copy reloc. Set it up. */
1675 BFD_ASSERT (h->dynindx != -1
1676 && (h->root.type == bfd_link_hash_defined
1677 || h->root.type == bfd_link_hash_defweak));
1679 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1681 BFD_ASSERT (s != NULL);
1683 rel.r_offset = (h->root.u.def.value
1684 + h->root.u.def.section->output_section->vma
1685 + h->root.u.def.section->output_offset);
1686 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1687 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1688 ((Elf32_External_Rel *) s->contents
1693 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1694 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1695 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1696 sym->st_shndx = SHN_ABS;
1701 /* Finish up the dynamic sections. */
1704 elf_i386_finish_dynamic_sections (output_bfd, info)
1706 struct bfd_link_info *info;
1712 dynobj = elf_hash_table (info)->dynobj;
1714 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1715 BFD_ASSERT (sgot != NULL);
1716 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1718 if (elf_hash_table (info)->dynamic_sections_created)
1721 Elf32_External_Dyn *dyncon, *dynconend;
1723 splt = bfd_get_section_by_name (dynobj, ".plt");
1724 BFD_ASSERT (splt != NULL && sdyn != NULL);
1726 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1727 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1728 for (; dyncon < dynconend; dyncon++)
1730 Elf_Internal_Dyn dyn;
1734 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1747 s = bfd_get_section_by_name (output_bfd, name);
1748 BFD_ASSERT (s != NULL);
1749 dyn.d_un.d_ptr = s->vma;
1750 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1754 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1755 BFD_ASSERT (s != NULL);
1756 if (s->_cooked_size != 0)
1757 dyn.d_un.d_val = s->_cooked_size;
1759 dyn.d_un.d_val = s->_raw_size;
1760 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1764 /* My reading of the SVR4 ABI indicates that the
1765 procedure linkage table relocs (DT_JMPREL) should be
1766 included in the overall relocs (DT_REL). This is
1767 what Solaris does. However, UnixWare can not handle
1768 that case. Therefore, we override the DT_RELSZ entry
1769 here to make it not include the JMPREL relocs. Since
1770 the linker script arranges for .rel.plt to follow all
1771 other relocation sections, we don't have to worry
1772 about changing the DT_REL entry. */
1773 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1776 if (s->_cooked_size != 0)
1777 dyn.d_un.d_val -= s->_cooked_size;
1779 dyn.d_un.d_val -= s->_raw_size;
1781 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1786 /* Fill in the first entry in the procedure linkage table. */
1787 if (splt->_raw_size > 0)
1790 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1793 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1794 bfd_put_32 (output_bfd,
1795 sgot->output_section->vma + sgot->output_offset + 4,
1796 splt->contents + 2);
1797 bfd_put_32 (output_bfd,
1798 sgot->output_section->vma + sgot->output_offset + 8,
1799 splt->contents + 8);
1803 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1804 really seem like the right value. */
1805 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1808 /* Fill in the first three entries in the global offset table. */
1809 if (sgot->_raw_size > 0)
1812 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1814 bfd_put_32 (output_bfd,
1815 sdyn->output_section->vma + sdyn->output_offset,
1817 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1818 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1821 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1826 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1827 #define TARGET_LITTLE_NAME "elf32-i386"
1828 #define ELF_ARCH bfd_arch_i386
1829 #define ELF_MACHINE_CODE EM_386
1830 #define ELF_MAXPAGESIZE 0x1000
1831 #define elf_info_to_howto elf_i386_info_to_howto
1832 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1833 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1834 #define bfd_elf32_bfd_is_local_label_name \
1835 elf_i386_is_local_label_name
1836 #define elf_backend_create_dynamic_sections \
1837 _bfd_elf_create_dynamic_sections
1838 #define bfd_elf32_bfd_link_hash_table_create \
1839 elf_i386_link_hash_table_create
1840 #define elf_backend_check_relocs elf_i386_check_relocs
1841 #define elf_backend_adjust_dynamic_symbol \
1842 elf_i386_adjust_dynamic_symbol
1843 #define elf_backend_size_dynamic_sections \
1844 elf_i386_size_dynamic_sections
1845 #define elf_backend_relocate_section elf_i386_relocate_section
1846 #define elf_backend_finish_dynamic_symbol \
1847 elf_i386_finish_dynamic_symbol
1848 #define elf_backend_finish_dynamic_sections \
1849 elf_i386_finish_dynamic_sections
1850 #define elf_backend_want_got_plt 1
1851 #define elf_backend_plt_readonly 1
1852 #define elf_backend_want_plt_sym 0
1854 #include "elf32-target.h"