* Makefile.am: Rebuild dependencies.
[binutils.git] / bfd / elf32-i386.c
blob830c680e8850aaf2735da5480abf6588b59a12bc
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993-1998, 1999 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. */
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "bfdlink.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
26 static reloc_howto_type *elf_i386_reloc_type_lookup
27 PARAMS ((bfd *, bfd_reloc_code_real_type));
28 static void elf_i386_info_to_howto
29 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
30 static void elf_i386_info_to_howto_rel
31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
32 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
33 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
36 PARAMS ((bfd *));
37 static boolean elf_i386_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
40 static boolean elf_i386_adjust_dynamic_symbol
41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
42 static boolean elf_i386_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44 static boolean elf_i386_relocate_section
45 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
46 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
47 static boolean elf_i386_finish_dynamic_symbol
48 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
49 Elf_Internal_Sym *));
50 static boolean elf_i386_finish_dynamic_sections
51 PARAMS ((bfd *, struct bfd_link_info *));
53 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
55 #include "elf/i386.h"
57 static reloc_howto_type elf_howto_table[]=
59 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false),
60 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false),
61 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true),
62 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
63 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
64 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false),
65 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),
66 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),
67 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
68 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
69 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
70 { 11 },
71 { 12 },
72 { 13 },
73 { 14 },
74 { 15 },
75 { 16 },
76 { 17 },
77 { 18 },
78 { 19 },
79 /* The remaining relocs are a GNU extension. */
80 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false),
81 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true),
82 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false),
83 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true),
86 /* GNU extension to record C++ vtable hierarchy. */
87 static reloc_howto_type elf32_i386_vtinherit_howto =
88 HOWTO (R_386_GNU_VTINHERIT, /* type */
89 0, /* rightshift */
90 2, /* size (0 = byte, 1 = short, 2 = long) */
91 0, /* bitsize */
92 false, /* pc_relative */
93 0, /* bitpos */
94 complain_overflow_dont, /* complain_on_overflow */
95 NULL, /* special_function */
96 "R_386_GNU_VTINHERIT", /* name */
97 false, /* partial_inplace */
98 0, /* src_mask */
99 0, /* dst_mask */
100 false);
102 /* GNU extension to record C++ vtable member usage. */
103 static reloc_howto_type elf32_i386_vtentry_howto =
104 HOWTO (R_386_GNU_VTENTRY, /* type */
105 0, /* rightshift */
106 2, /* size (0 = byte, 1 = short, 2 = long) */
107 0, /* bitsize */
108 false, /* pc_relative */
109 0, /* bitpos */
110 complain_overflow_dont, /* complain_on_overflow */
111 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
112 "R_386_GNU_VTENTRY", /* name */
113 false, /* partial_inplace */
114 0, /* src_mask */
115 0, /* dst_mask */
116 false);
118 #ifdef DEBUG_GEN_RELOC
119 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
120 #else
121 #define TRACE(str)
122 #endif
124 static reloc_howto_type *
125 elf_i386_reloc_type_lookup (abfd, code)
126 bfd *abfd;
127 bfd_reloc_code_real_type code;
129 switch (code)
131 case BFD_RELOC_NONE:
132 TRACE ("BFD_RELOC_NONE");
133 return &elf_howto_table[ (int)R_386_NONE ];
135 case BFD_RELOC_32:
136 TRACE ("BFD_RELOC_32");
137 return &elf_howto_table[ (int)R_386_32 ];
139 case BFD_RELOC_CTOR:
140 TRACE ("BFD_RELOC_CTOR");
141 return &elf_howto_table[ (int)R_386_32 ];
143 case BFD_RELOC_32_PCREL:
144 TRACE ("BFD_RELOC_PC32");
145 return &elf_howto_table[ (int)R_386_PC32 ];
147 case BFD_RELOC_386_GOT32:
148 TRACE ("BFD_RELOC_386_GOT32");
149 return &elf_howto_table[ (int)R_386_GOT32 ];
151 case BFD_RELOC_386_PLT32:
152 TRACE ("BFD_RELOC_386_PLT32");
153 return &elf_howto_table[ (int)R_386_PLT32 ];
155 case BFD_RELOC_386_COPY:
156 TRACE ("BFD_RELOC_386_COPY");
157 return &elf_howto_table[ (int)R_386_COPY ];
159 case BFD_RELOC_386_GLOB_DAT:
160 TRACE ("BFD_RELOC_386_GLOB_DAT");
161 return &elf_howto_table[ (int)R_386_GLOB_DAT ];
163 case BFD_RELOC_386_JUMP_SLOT:
164 TRACE ("BFD_RELOC_386_JUMP_SLOT");
165 return &elf_howto_table[ (int)R_386_JUMP_SLOT ];
167 case BFD_RELOC_386_RELATIVE:
168 TRACE ("BFD_RELOC_386_RELATIVE");
169 return &elf_howto_table[ (int)R_386_RELATIVE ];
171 case BFD_RELOC_386_GOTOFF:
172 TRACE ("BFD_RELOC_386_GOTOFF");
173 return &elf_howto_table[ (int)R_386_GOTOFF ];
175 case BFD_RELOC_386_GOTPC:
176 TRACE ("BFD_RELOC_386_GOTPC");
177 return &elf_howto_table[ (int)R_386_GOTPC ];
179 /* The remaining relocs are a GNU extension. */
180 case BFD_RELOC_16:
181 TRACE ("BFD_RELOC_16");
182 return &elf_howto_table[(int) R_386_16];
184 case BFD_RELOC_16_PCREL:
185 TRACE ("BFD_RELOC_16_PCREL");
186 return &elf_howto_table[(int) R_386_PC16];
188 case BFD_RELOC_8:
189 TRACE ("BFD_RELOC_8");
190 return &elf_howto_table[(int) R_386_8];
192 case BFD_RELOC_8_PCREL:
193 TRACE ("BFD_RELOC_8_PCREL");
194 return &elf_howto_table[(int) R_386_PC8];
196 case BFD_RELOC_VTABLE_INHERIT:
197 TRACE ("BFD_RELOC_VTABLE_INHERIT");
198 return &elf32_i386_vtinherit_howto;
200 case BFD_RELOC_VTABLE_ENTRY:
201 TRACE ("BFD_RELOC_VTABLE_ENTRY");
202 return &elf32_i386_vtentry_howto;
204 default:
205 break;
208 TRACE ("Unknown");
209 return 0;
212 static void
213 elf_i386_info_to_howto (abfd, cache_ptr, dst)
214 bfd *abfd;
215 arelent *cache_ptr;
216 Elf32_Internal_Rela *dst;
218 abort ();
221 static void
222 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
223 bfd *abfd;
224 arelent *cache_ptr;
225 Elf32_Internal_Rel *dst;
227 enum elf_i386_reloc_type type;
229 type = (enum elf_i386_reloc_type) ELF32_R_TYPE (dst->r_info);
230 if (type == R_386_GNU_VTINHERIT)
231 cache_ptr->howto = &elf32_i386_vtinherit_howto;
232 else if (type == R_386_GNU_VTENTRY)
233 cache_ptr->howto = &elf32_i386_vtentry_howto;
234 else
236 BFD_ASSERT (type < R_386_max);
237 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC);
238 cache_ptr->howto = &elf_howto_table[(int) type];
242 /* Return whether a symbol name implies a local label. The UnixWare
243 2.1 cc generates temporary symbols that start with .X, so we
244 recognize them here. FIXME: do other SVR4 compilers also use .X?.
245 If so, we should move the .X recognition into
246 _bfd_elf_is_local_label_name. */
248 static boolean
249 elf_i386_is_local_label_name (abfd, name)
250 bfd *abfd;
251 const char *name;
253 if (name[0] == '.' && name[1] == 'X')
254 return true;
256 return _bfd_elf_is_local_label_name (abfd, name);
259 /* Functions for the i386 ELF linker. */
261 /* The name of the dynamic interpreter. This is put in the .interp
262 section. */
264 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
266 /* The size in bytes of an entry in the procedure linkage table. */
268 #define PLT_ENTRY_SIZE 16
270 /* The first entry in an absolute procedure linkage table looks like
271 this. See the SVR4 ABI i386 supplement to see how this works. */
273 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
275 0xff, 0x35, /* pushl contents of address */
276 0, 0, 0, 0, /* replaced with address of .got + 4. */
277 0xff, 0x25, /* jmp indirect */
278 0, 0, 0, 0, /* replaced with address of .got + 8. */
279 0, 0, 0, 0 /* pad out to 16 bytes. */
282 /* Subsequent entries in an absolute procedure linkage table look like
283 this. */
285 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
287 0xff, 0x25, /* jmp indirect */
288 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
289 0x68, /* pushl immediate */
290 0, 0, 0, 0, /* replaced with offset into relocation table. */
291 0xe9, /* jmp relative */
292 0, 0, 0, 0 /* replaced with offset to start of .plt. */
295 /* The first entry in a PIC procedure linkage table look like this. */
297 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
299 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
300 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
301 0, 0, 0, 0 /* pad out to 16 bytes. */
304 /* Subsequent entries in a PIC procedure linkage table look like this. */
306 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
308 0xff, 0xa3, /* jmp *offset(%ebx) */
309 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
310 0x68, /* pushl immediate */
311 0, 0, 0, 0, /* replaced with offset into relocation table. */
312 0xe9, /* jmp relative */
313 0, 0, 0, 0 /* replaced with offset to start of .plt. */
316 /* The i386 linker needs to keep track of the number of relocs that it
317 decides to copy in check_relocs for each symbol. This is so that
318 it can discard PC relative relocs if it doesn't need them when
319 linking with -Bsymbolic. We store the information in a field
320 extending the regular ELF linker hash table. */
322 /* This structure keeps track of the number of PC relative relocs we
323 have copied for a given symbol. */
325 struct elf_i386_pcrel_relocs_copied
327 /* Next section. */
328 struct elf_i386_pcrel_relocs_copied *next;
329 /* A section in dynobj. */
330 asection *section;
331 /* Number of relocs copied in this section. */
332 bfd_size_type count;
335 /* i386 ELF linker hash entry. */
337 struct elf_i386_link_hash_entry
339 struct elf_link_hash_entry root;
341 /* Number of PC relative relocs copied for this symbol. */
342 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
345 /* i386 ELF linker hash table. */
347 struct elf_i386_link_hash_table
349 struct elf_link_hash_table root;
352 /* Declare this now that the above structures are defined. */
354 static boolean elf_i386_discard_copies
355 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
357 /* Traverse an i386 ELF linker hash table. */
359 #define elf_i386_link_hash_traverse(table, func, info) \
360 (elf_link_hash_traverse \
361 (&(table)->root, \
362 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
363 (info)))
365 /* Get the i386 ELF linker hash table from a link_info structure. */
367 #define elf_i386_hash_table(p) \
368 ((struct elf_i386_link_hash_table *) ((p)->hash))
370 /* Create an entry in an i386 ELF linker hash table. */
372 static struct bfd_hash_entry *
373 elf_i386_link_hash_newfunc (entry, table, string)
374 struct bfd_hash_entry *entry;
375 struct bfd_hash_table *table;
376 const char *string;
378 struct elf_i386_link_hash_entry *ret =
379 (struct elf_i386_link_hash_entry *) entry;
381 /* Allocate the structure if it has not already been allocated by a
382 subclass. */
383 if (ret == (struct elf_i386_link_hash_entry *) NULL)
384 ret = ((struct elf_i386_link_hash_entry *)
385 bfd_hash_allocate (table,
386 sizeof (struct elf_i386_link_hash_entry)));
387 if (ret == (struct elf_i386_link_hash_entry *) NULL)
388 return (struct bfd_hash_entry *) ret;
390 /* Call the allocation method of the superclass. */
391 ret = ((struct elf_i386_link_hash_entry *)
392 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
393 table, string));
394 if (ret != (struct elf_i386_link_hash_entry *) NULL)
396 ret->pcrel_relocs_copied = NULL;
399 return (struct bfd_hash_entry *) ret;
402 /* Create an i386 ELF linker hash table. */
404 static struct bfd_link_hash_table *
405 elf_i386_link_hash_table_create (abfd)
406 bfd *abfd;
408 struct elf_i386_link_hash_table *ret;
410 ret = ((struct elf_i386_link_hash_table *)
411 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
412 if (ret == (struct elf_i386_link_hash_table *) NULL)
413 return NULL;
415 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
416 elf_i386_link_hash_newfunc))
418 bfd_release (abfd, ret);
419 return NULL;
422 return &ret->root.root;
425 /* Look through the relocs for a section during the first phase, and
426 allocate space in the global offset table or procedure linkage
427 table. */
429 static boolean
430 elf_i386_check_relocs (abfd, info, sec, relocs)
431 bfd *abfd;
432 struct bfd_link_info *info;
433 asection *sec;
434 const Elf_Internal_Rela *relocs;
436 bfd *dynobj;
437 Elf_Internal_Shdr *symtab_hdr;
438 struct elf_link_hash_entry **sym_hashes;
439 bfd_vma *local_got_offsets;
440 const Elf_Internal_Rela *rel;
441 const Elf_Internal_Rela *rel_end;
442 asection *sgot;
443 asection *srelgot;
444 asection *sreloc;
446 if (info->relocateable)
447 return true;
449 dynobj = elf_hash_table (info)->dynobj;
450 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
451 sym_hashes = elf_sym_hashes (abfd);
452 local_got_offsets = elf_local_got_offsets (abfd);
454 sgot = NULL;
455 srelgot = NULL;
456 sreloc = NULL;
458 rel_end = relocs + sec->reloc_count;
459 for (rel = relocs; rel < rel_end; rel++)
461 unsigned long r_symndx;
462 struct elf_link_hash_entry *h;
464 r_symndx = ELF32_R_SYM (rel->r_info);
466 if (r_symndx < symtab_hdr->sh_info)
467 h = NULL;
468 else
469 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
471 /* Some relocs require a global offset table. */
472 if (dynobj == NULL)
474 switch (ELF32_R_TYPE (rel->r_info))
476 case R_386_GOT32:
477 case R_386_GOTOFF:
478 case R_386_GOTPC:
479 elf_hash_table (info)->dynobj = dynobj = abfd;
480 if (! _bfd_elf_create_got_section (dynobj, info))
481 return false;
482 break;
484 default:
485 break;
489 switch (ELF32_R_TYPE (rel->r_info))
491 case R_386_GOT32:
492 /* This symbol requires a global offset table entry. */
494 if (sgot == NULL)
496 sgot = bfd_get_section_by_name (dynobj, ".got");
497 BFD_ASSERT (sgot != NULL);
500 if (srelgot == NULL
501 && (h != NULL || info->shared))
503 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
504 if (srelgot == NULL)
506 srelgot = bfd_make_section (dynobj, ".rel.got");
507 if (srelgot == NULL
508 || ! bfd_set_section_flags (dynobj, srelgot,
509 (SEC_ALLOC
510 | SEC_LOAD
511 | SEC_HAS_CONTENTS
512 | SEC_IN_MEMORY
513 | SEC_LINKER_CREATED
514 | SEC_READONLY))
515 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
516 return false;
520 if (h != NULL)
522 if (h->got.offset != (bfd_vma) -1)
524 /* We have already allocated space in the .got. */
525 break;
527 h->got.offset = sgot->_raw_size;
529 /* Make sure this symbol is output as a dynamic symbol. */
530 if (h->dynindx == -1)
532 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
533 return false;
536 srelgot->_raw_size += sizeof (Elf32_External_Rel);
538 else
540 /* This is a global offset table entry for a local
541 symbol. */
542 if (local_got_offsets == NULL)
544 size_t size;
545 register unsigned int i;
547 size = symtab_hdr->sh_info * sizeof (bfd_vma);
548 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
549 if (local_got_offsets == NULL)
550 return false;
551 elf_local_got_offsets (abfd) = local_got_offsets;
552 for (i = 0; i < symtab_hdr->sh_info; i++)
553 local_got_offsets[i] = (bfd_vma) -1;
555 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
557 /* We have already allocated space in the .got. */
558 break;
560 local_got_offsets[r_symndx] = sgot->_raw_size;
562 if (info->shared)
564 /* If we are generating a shared object, we need to
565 output a R_386_RELATIVE reloc so that the dynamic
566 linker can adjust this GOT entry. */
567 srelgot->_raw_size += sizeof (Elf32_External_Rel);
571 sgot->_raw_size += 4;
573 break;
575 case R_386_PLT32:
576 /* This symbol requires a procedure linkage table entry. We
577 actually build the entry in adjust_dynamic_symbol,
578 because this might be a case of linking PIC code which is
579 never referenced by a dynamic object, in which case we
580 don't need to generate a procedure linkage table entry
581 after all. */
583 /* If this is a local symbol, we resolve it directly without
584 creating a procedure linkage table entry. */
585 if (h == NULL)
586 continue;
588 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
590 break;
592 case R_386_32:
593 case R_386_PC32:
594 /* If we are creating a shared library, and this is a reloc
595 against a global symbol, or a non PC relative reloc
596 against a local symbol, then we need to copy the reloc
597 into the shared library. However, if we are linking with
598 -Bsymbolic, we do not need to copy a reloc against a
599 global symbol which is defined in an object we are
600 including in the link (i.e., DEF_REGULAR is set). At
601 this point we have not seen all the input files, so it is
602 possible that DEF_REGULAR is not set now but will be set
603 later (it is never cleared). We account for that
604 possibility below by storing information in the
605 pcrel_relocs_copied field of the hash table entry. */
606 if (info->shared
607 && (sec->flags & SEC_ALLOC) != 0
608 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
609 || (h != NULL
610 && (! info->symbolic
611 || (h->elf_link_hash_flags
612 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
614 /* When creating a shared object, we must copy these
615 reloc types into the output file. We create a reloc
616 section in dynobj and make room for this reloc. */
617 if (sreloc == NULL)
619 const char *name;
621 name = (bfd_elf_string_from_elf_section
622 (abfd,
623 elf_elfheader (abfd)->e_shstrndx,
624 elf_section_data (sec)->rel_hdr.sh_name));
625 if (name == NULL)
626 return false;
628 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
629 && strcmp (bfd_get_section_name (abfd, sec),
630 name + 4) == 0);
632 sreloc = bfd_get_section_by_name (dynobj, name);
633 if (sreloc == NULL)
635 flagword flags;
637 sreloc = bfd_make_section (dynobj, name);
638 flags = (SEC_HAS_CONTENTS | SEC_READONLY
639 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
640 if ((sec->flags & SEC_ALLOC) != 0)
641 flags |= SEC_ALLOC | SEC_LOAD;
642 if (sreloc == NULL
643 || ! bfd_set_section_flags (dynobj, sreloc, flags)
644 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
645 return false;
649 sreloc->_raw_size += sizeof (Elf32_External_Rel);
651 /* If we are linking with -Bsymbolic, and this is a
652 global symbol, we count the number of PC relative
653 relocations we have entered for this symbol, so that
654 we can discard them again if the symbol is later
655 defined by a regular object. Note that this function
656 is only called if we are using an elf_i386 linker
657 hash table, which means that h is really a pointer to
658 an elf_i386_link_hash_entry. */
659 if (h != NULL && info->symbolic
660 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
662 struct elf_i386_link_hash_entry *eh;
663 struct elf_i386_pcrel_relocs_copied *p;
665 eh = (struct elf_i386_link_hash_entry *) h;
667 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
668 if (p->section == sreloc)
669 break;
671 if (p == NULL)
673 p = ((struct elf_i386_pcrel_relocs_copied *)
674 bfd_alloc (dynobj, sizeof *p));
675 if (p == NULL)
676 return false;
677 p->next = eh->pcrel_relocs_copied;
678 eh->pcrel_relocs_copied = p;
679 p->section = sreloc;
680 p->count = 0;
683 ++p->count;
687 break;
689 /* This relocation describes the C++ object vtable hierarchy.
690 Reconstruct it for later use during GC. */
691 case R_386_GNU_VTINHERIT:
692 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
693 return false;
694 break;
696 /* This relocation describes which C++ vtable entries are actually
697 used. Record for later use during GC. */
698 case R_386_GNU_VTENTRY:
699 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
700 return false;
701 break;
703 default:
704 break;
708 return true;
711 /* Return the section that should be marked against GC for a given
712 relocation. */
714 static asection *
715 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
716 bfd *abfd;
717 struct bfd_link_info *info;
718 Elf_Internal_Rela *rel;
719 struct elf_link_hash_entry *h;
720 Elf_Internal_Sym *sym;
722 if (h != NULL)
724 switch (ELF32_R_TYPE (rel->r_info))
726 case R_386_GNU_VTINHERIT:
727 case R_386_GNU_VTENTRY:
728 break;
730 default:
731 switch (h->root.type)
733 case bfd_link_hash_defined:
734 case bfd_link_hash_defweak:
735 return h->root.u.def.section;
737 case bfd_link_hash_common:
738 return h->root.u.c.p->section;
740 default:
741 break;
745 else
747 if (!(elf_bad_symtab (abfd)
748 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
749 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
750 && sym->st_shndx != SHN_COMMON))
752 return bfd_section_from_elf_index (abfd, sym->st_shndx);
756 return NULL;
759 /* Update the got entry reference counts for the section being removed. */
761 static boolean
762 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
763 bfd *abfd;
764 struct bfd_link_info *info;
765 asection *sec;
766 const Elf_Internal_Rela *relocs;
768 /* ??? It would seem that the existing i386 code does no sort
769 of reference counting or whatnot on its GOT and PLT entries,
770 so it is not possible to garbage collect them at this time. */
772 return true;
775 /* Adjust a symbol defined by a dynamic object and referenced by a
776 regular object. The current definition is in some section of the
777 dynamic object, but we're not including those sections. We have to
778 change the definition to something the rest of the link can
779 understand. */
781 static boolean
782 elf_i386_adjust_dynamic_symbol (info, h)
783 struct bfd_link_info *info;
784 struct elf_link_hash_entry *h;
786 bfd *dynobj;
787 asection *s;
788 unsigned int power_of_two;
790 dynobj = elf_hash_table (info)->dynobj;
792 /* Make sure we know what is going on here. */
793 BFD_ASSERT (dynobj != NULL
794 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
795 || h->weakdef != NULL
796 || ((h->elf_link_hash_flags
797 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
798 && (h->elf_link_hash_flags
799 & ELF_LINK_HASH_REF_REGULAR) != 0
800 && (h->elf_link_hash_flags
801 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
803 /* If this is a function, put it in the procedure linkage table. We
804 will fill in the contents of the procedure linkage table later,
805 when we know the address of the .got section. */
806 if (h->type == STT_FUNC
807 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
809 if (! info->shared
810 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
811 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
813 /* This case can occur if we saw a PLT32 reloc in an input
814 file, but the symbol was never referred to by a dynamic
815 object. In such a case, we don't actually need to build
816 a procedure linkage table, and we can just do a PC32
817 reloc instead. */
818 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
819 return true;
822 /* Make sure this symbol is output as a dynamic symbol. */
823 if (h->dynindx == -1)
825 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
826 return false;
829 s = bfd_get_section_by_name (dynobj, ".plt");
830 BFD_ASSERT (s != NULL);
832 /* If this is the first .plt entry, make room for the special
833 first entry. */
834 if (s->_raw_size == 0)
835 s->_raw_size += PLT_ENTRY_SIZE;
837 /* If this symbol is not defined in a regular file, and we are
838 not generating a shared library, then set the symbol to this
839 location in the .plt. This is required to make function
840 pointers compare as equal between the normal executable and
841 the shared library. */
842 if (! info->shared
843 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
845 h->root.u.def.section = s;
846 h->root.u.def.value = s->_raw_size;
849 h->plt.offset = s->_raw_size;
851 /* Make room for this entry. */
852 s->_raw_size += PLT_ENTRY_SIZE;
854 /* We also need to make an entry in the .got.plt section, which
855 will be placed in the .got section by the linker script. */
857 s = bfd_get_section_by_name (dynobj, ".got.plt");
858 BFD_ASSERT (s != NULL);
859 s->_raw_size += 4;
861 /* We also need to make an entry in the .rel.plt section. */
863 s = bfd_get_section_by_name (dynobj, ".rel.plt");
864 BFD_ASSERT (s != NULL);
865 s->_raw_size += sizeof (Elf32_External_Rel);
867 return true;
870 /* If this is a weak symbol, and there is a real definition, the
871 processor independent code will have arranged for us to see the
872 real definition first, and we can just use the same value. */
873 if (h->weakdef != NULL)
875 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
876 || h->weakdef->root.type == bfd_link_hash_defweak);
877 h->root.u.def.section = h->weakdef->root.u.def.section;
878 h->root.u.def.value = h->weakdef->root.u.def.value;
879 return true;
882 /* This is a reference to a symbol defined by a dynamic object which
883 is not a function. */
885 /* If we are creating a shared library, we must presume that the
886 only references to the symbol are via the global offset table.
887 For such cases we need not do anything here; the relocations will
888 be handled correctly by relocate_section. */
889 if (info->shared)
890 return true;
892 /* We must allocate the symbol in our .dynbss section, which will
893 become part of the .bss section of the executable. There will be
894 an entry for this symbol in the .dynsym section. The dynamic
895 object will contain position independent code, so all references
896 from the dynamic object to this symbol will go through the global
897 offset table. The dynamic linker will use the .dynsym entry to
898 determine the address it must put in the global offset table, so
899 both the dynamic object and the regular object will refer to the
900 same memory location for the variable. */
902 s = bfd_get_section_by_name (dynobj, ".dynbss");
903 BFD_ASSERT (s != NULL);
905 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
906 copy the initial value out of the dynamic object and into the
907 runtime process image. We need to remember the offset into the
908 .rel.bss section we are going to use. */
909 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
911 asection *srel;
913 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
914 BFD_ASSERT (srel != NULL);
915 srel->_raw_size += sizeof (Elf32_External_Rel);
916 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
919 /* We need to figure out the alignment required for this symbol. I
920 have no idea how ELF linkers handle this. */
921 power_of_two = bfd_log2 (h->size);
922 if (power_of_two > 3)
923 power_of_two = 3;
925 /* Apply the required alignment. */
926 s->_raw_size = BFD_ALIGN (s->_raw_size,
927 (bfd_size_type) (1 << power_of_two));
928 if (power_of_two > bfd_get_section_alignment (dynobj, s))
930 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
931 return false;
934 /* Define the symbol as being at this point in the section. */
935 h->root.u.def.section = s;
936 h->root.u.def.value = s->_raw_size;
938 /* Increment the section size to make room for the symbol. */
939 s->_raw_size += h->size;
941 return true;
944 /* Set the sizes of the dynamic sections. */
946 static boolean
947 elf_i386_size_dynamic_sections (output_bfd, info)
948 bfd *output_bfd;
949 struct bfd_link_info *info;
951 bfd *dynobj;
952 asection *s;
953 boolean plt;
954 boolean relocs;
955 boolean reltext;
957 dynobj = elf_hash_table (info)->dynobj;
958 BFD_ASSERT (dynobj != NULL);
960 if (elf_hash_table (info)->dynamic_sections_created)
962 /* Set the contents of the .interp section to the interpreter. */
963 if (! info->shared)
965 s = bfd_get_section_by_name (dynobj, ".interp");
966 BFD_ASSERT (s != NULL);
967 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
968 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
971 else
973 /* We may have created entries in the .rel.got section.
974 However, if we are not creating the dynamic sections, we will
975 not actually use these entries. Reset the size of .rel.got,
976 which will cause it to get stripped from the output file
977 below. */
978 s = bfd_get_section_by_name (dynobj, ".rel.got");
979 if (s != NULL)
980 s->_raw_size = 0;
983 /* If this is a -Bsymbolic shared link, then we need to discard all
984 PC relative relocs against symbols defined in a regular object.
985 We allocated space for them in the check_relocs routine, but we
986 will not fill them in in the relocate_section routine. */
987 if (info->shared && info->symbolic)
988 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
989 elf_i386_discard_copies,
990 (PTR) NULL);
992 /* The check_relocs and adjust_dynamic_symbol entry points have
993 determined the sizes of the various dynamic sections. Allocate
994 memory for them. */
995 plt = false;
996 relocs = false;
997 reltext = false;
998 for (s = dynobj->sections; s != NULL; s = s->next)
1000 const char *name;
1001 boolean strip;
1003 if ((s->flags & SEC_LINKER_CREATED) == 0)
1004 continue;
1006 /* It's OK to base decisions on the section name, because none
1007 of the dynobj section names depend upon the input files. */
1008 name = bfd_get_section_name (dynobj, s);
1010 strip = false;
1012 if (strcmp (name, ".plt") == 0)
1014 if (s->_raw_size == 0)
1016 /* Strip this section if we don't need it; see the
1017 comment below. */
1018 strip = true;
1020 else
1022 /* Remember whether there is a PLT. */
1023 plt = true;
1026 else if (strncmp (name, ".rel", 4) == 0)
1028 if (s->_raw_size == 0)
1030 /* If we don't need this section, strip it from the
1031 output file. This is mostly to handle .rel.bss and
1032 .rel.plt. We must create both sections in
1033 create_dynamic_sections, because they must be created
1034 before the linker maps input sections to output
1035 sections. The linker does that before
1036 adjust_dynamic_symbol is called, and it is that
1037 function which decides whether anything needs to go
1038 into these sections. */
1039 strip = true;
1041 else
1043 asection *target;
1045 /* Remember whether there are any reloc sections other
1046 than .rel.plt. */
1047 if (strcmp (name, ".rel.plt") != 0)
1049 const char *outname;
1051 relocs = true;
1053 /* If this relocation section applies to a read only
1054 section, then we probably need a DT_TEXTREL
1055 entry. The entries in the .rel.plt section
1056 really apply to the .got section, which we
1057 created ourselves and so know is not readonly. */
1058 outname = bfd_get_section_name (output_bfd,
1059 s->output_section);
1060 target = bfd_get_section_by_name (output_bfd, outname + 4);
1061 if (target != NULL
1062 && (target->flags & SEC_READONLY) != 0
1063 && (target->flags & SEC_ALLOC) != 0)
1064 reltext = true;
1067 /* We use the reloc_count field as a counter if we need
1068 to copy relocs into the output file. */
1069 s->reloc_count = 0;
1072 else if (strncmp (name, ".got", 4) != 0)
1074 /* It's not one of our sections, so don't allocate space. */
1075 continue;
1078 if (strip)
1080 _bfd_strip_section_from_output (s);
1081 continue;
1084 /* Allocate memory for the section contents. */
1085 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1086 if (s->contents == NULL && s->_raw_size != 0)
1087 return false;
1090 if (elf_hash_table (info)->dynamic_sections_created)
1092 /* Add some entries to the .dynamic section. We fill in the
1093 values later, in elf_i386_finish_dynamic_sections, but we
1094 must add the entries now so that we get the correct size for
1095 the .dynamic section. The DT_DEBUG entry is filled in by the
1096 dynamic linker and used by the debugger. */
1097 if (! info->shared)
1099 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1100 return false;
1103 if (plt)
1105 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1106 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1107 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1108 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1109 return false;
1112 if (relocs)
1114 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1115 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1116 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1117 sizeof (Elf32_External_Rel)))
1118 return false;
1121 if (reltext)
1123 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1124 return false;
1128 return true;
1131 /* This function is called via elf_i386_link_hash_traverse if we are
1132 creating a shared object with -Bsymbolic. It discards the space
1133 allocated to copy PC relative relocs against symbols which are
1134 defined in regular objects. We allocated space for them in the
1135 check_relocs routine, but we won't fill them in in the
1136 relocate_section routine. */
1138 /*ARGSUSED*/
1139 static boolean
1140 elf_i386_discard_copies (h, ignore)
1141 struct elf_i386_link_hash_entry *h;
1142 PTR ignore;
1144 struct elf_i386_pcrel_relocs_copied *s;
1146 /* We only discard relocs for symbols defined in a regular object. */
1147 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1148 return true;
1150 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1151 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1153 return true;
1156 /* Relocate an i386 ELF section. */
1158 static boolean
1159 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1160 contents, relocs, local_syms, local_sections)
1161 bfd *output_bfd;
1162 struct bfd_link_info *info;
1163 bfd *input_bfd;
1164 asection *input_section;
1165 bfd_byte *contents;
1166 Elf_Internal_Rela *relocs;
1167 Elf_Internal_Sym *local_syms;
1168 asection **local_sections;
1170 bfd *dynobj;
1171 Elf_Internal_Shdr *symtab_hdr;
1172 struct elf_link_hash_entry **sym_hashes;
1173 bfd_vma *local_got_offsets;
1174 asection *sgot;
1175 asection *splt;
1176 asection *sreloc;
1177 Elf_Internal_Rela *rel;
1178 Elf_Internal_Rela *relend;
1180 dynobj = elf_hash_table (info)->dynobj;
1181 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1182 sym_hashes = elf_sym_hashes (input_bfd);
1183 local_got_offsets = elf_local_got_offsets (input_bfd);
1185 sgot = NULL;
1186 splt = NULL;
1187 sreloc = NULL;
1189 rel = relocs;
1190 relend = relocs + input_section->reloc_count;
1191 for (; rel < relend; rel++)
1193 int r_type;
1194 reloc_howto_type *howto;
1195 unsigned long r_symndx;
1196 struct elf_link_hash_entry *h;
1197 Elf_Internal_Sym *sym;
1198 asection *sec;
1199 bfd_vma relocation;
1200 bfd_reloc_status_type r;
1202 r_type = ELF32_R_TYPE (rel->r_info);
1203 if (r_type == R_386_GNU_VTINHERIT
1204 || r_type == R_386_GNU_VTENTRY)
1205 continue;
1206 if (r_type < 0
1207 || r_type >= (int) R_386_max
1208 || (r_type >= (int) FIRST_INVALID_RELOC
1209 && r_type <= (int) LAST_INVALID_RELOC))
1211 bfd_set_error (bfd_error_bad_value);
1212 return false;
1214 howto = elf_howto_table + r_type;
1216 r_symndx = ELF32_R_SYM (rel->r_info);
1218 if (info->relocateable)
1220 /* This is a relocateable link. We don't have to change
1221 anything, unless the reloc is against a section symbol,
1222 in which case we have to adjust according to where the
1223 section symbol winds up in the output section. */
1224 if (r_symndx < symtab_hdr->sh_info)
1226 sym = local_syms + r_symndx;
1227 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1229 bfd_vma val;
1231 sec = local_sections[r_symndx];
1232 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1233 val += sec->output_offset + sym->st_value;
1234 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1238 continue;
1241 /* This is a final link. */
1242 h = NULL;
1243 sym = NULL;
1244 sec = NULL;
1245 if (r_symndx < symtab_hdr->sh_info)
1247 sym = local_syms + r_symndx;
1248 sec = local_sections[r_symndx];
1249 relocation = (sec->output_section->vma
1250 + sec->output_offset
1251 + sym->st_value);
1253 else
1255 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1256 while (h->root.type == bfd_link_hash_indirect
1257 || h->root.type == bfd_link_hash_warning)
1258 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1259 if (h->root.type == bfd_link_hash_defined
1260 || h->root.type == bfd_link_hash_defweak)
1262 sec = h->root.u.def.section;
1263 if (r_type == R_386_GOTPC
1264 || (r_type == R_386_PLT32
1265 && h->plt.offset != (bfd_vma) -1)
1266 || (r_type == R_386_GOT32
1267 && elf_hash_table (info)->dynamic_sections_created
1268 && (! info->shared
1269 || (! info->symbolic && h->dynindx != -1)
1270 || (h->elf_link_hash_flags
1271 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1272 || (info->shared
1273 && ((! info->symbolic && h->dynindx != -1)
1274 || (h->elf_link_hash_flags
1275 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1276 && (r_type == R_386_32
1277 || r_type == R_386_PC32)
1278 && ((input_section->flags & SEC_ALLOC) != 0
1279 /* DWARF will emit R_386_32 relocations in its
1280 sections against symbols defined externally
1281 in shared libraries. We can't do anything
1282 with them here. */
1283 || (input_section->flags & SEC_DEBUGGING) != 0)))
1285 /* In these cases, we don't need the relocation
1286 value. We check specially because in some
1287 obscure cases sec->output_section will be NULL. */
1288 relocation = 0;
1290 else if (sec->output_section == NULL)
1292 (*_bfd_error_handler)
1293 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1294 bfd_get_filename (input_bfd), h->root.root.string,
1295 bfd_get_section_name (input_bfd, input_section));
1296 relocation = 0;
1298 else
1299 relocation = (h->root.u.def.value
1300 + sec->output_section->vma
1301 + sec->output_offset);
1303 else if (h->root.type == bfd_link_hash_undefweak)
1304 relocation = 0;
1305 else if (info->shared && !info->symbolic && !info->no_undefined)
1306 relocation = 0;
1307 else
1309 if (! ((*info->callbacks->undefined_symbol)
1310 (info, h->root.root.string, input_bfd,
1311 input_section, rel->r_offset)))
1312 return false;
1313 relocation = 0;
1317 switch (r_type)
1319 case R_386_GOT32:
1320 /* Relocation is to the entry for this symbol in the global
1321 offset table. */
1322 if (sgot == NULL)
1324 sgot = bfd_get_section_by_name (dynobj, ".got");
1325 BFD_ASSERT (sgot != NULL);
1328 if (h != NULL)
1330 bfd_vma off;
1332 off = h->got.offset;
1333 BFD_ASSERT (off != (bfd_vma) -1);
1335 if (! elf_hash_table (info)->dynamic_sections_created
1336 || (info->shared
1337 && (info->symbolic || h->dynindx == -1)
1338 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1340 /* This is actually a static link, or it is a
1341 -Bsymbolic link and the symbol is defined
1342 locally, or the symbol was forced to be local
1343 because of a version file. We must initialize
1344 this entry in the global offset table. Since the
1345 offset must always be a multiple of 4, we use the
1346 least significant bit to record whether we have
1347 initialized it already.
1349 When doing a dynamic link, we create a .rel.got
1350 relocation entry to initialize the value. This
1351 is done in the finish_dynamic_symbol routine. */
1352 if ((off & 1) != 0)
1353 off &= ~1;
1354 else
1356 bfd_put_32 (output_bfd, relocation,
1357 sgot->contents + off);
1358 h->got.offset |= 1;
1362 relocation = sgot->output_offset + off;
1364 else
1366 bfd_vma off;
1368 BFD_ASSERT (local_got_offsets != NULL
1369 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1371 off = local_got_offsets[r_symndx];
1373 /* The offset must always be a multiple of 4. We use
1374 the least significant bit to record whether we have
1375 already generated the necessary reloc. */
1376 if ((off & 1) != 0)
1377 off &= ~1;
1378 else
1380 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1382 if (info->shared)
1384 asection *srelgot;
1385 Elf_Internal_Rel outrel;
1387 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1388 BFD_ASSERT (srelgot != NULL);
1390 outrel.r_offset = (sgot->output_section->vma
1391 + sgot->output_offset
1392 + off);
1393 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1394 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1395 (((Elf32_External_Rel *)
1396 srelgot->contents)
1397 + srelgot->reloc_count));
1398 ++srelgot->reloc_count;
1401 local_got_offsets[r_symndx] |= 1;
1404 relocation = sgot->output_offset + off;
1407 break;
1409 case R_386_GOTOFF:
1410 /* Relocation is relative to the start of the global offset
1411 table. */
1413 if (sgot == NULL)
1415 sgot = bfd_get_section_by_name (dynobj, ".got");
1416 BFD_ASSERT (sgot != NULL);
1419 /* Note that sgot->output_offset is not involved in this
1420 calculation. We always want the start of .got. If we
1421 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1422 permitted by the ABI, we might have to change this
1423 calculation. */
1424 relocation -= sgot->output_section->vma;
1426 break;
1428 case R_386_GOTPC:
1429 /* Use global offset table as symbol value. */
1431 if (sgot == NULL)
1433 sgot = bfd_get_section_by_name (dynobj, ".got");
1434 BFD_ASSERT (sgot != NULL);
1437 relocation = sgot->output_section->vma;
1439 break;
1441 case R_386_PLT32:
1442 /* Relocation is to the entry for this symbol in the
1443 procedure linkage table. */
1445 /* Resolve a PLT32 reloc again a local symbol directly,
1446 without using the procedure linkage table. */
1447 if (h == NULL)
1448 break;
1450 if (h->plt.offset == (bfd_vma) -1)
1452 /* We didn't make a PLT entry for this symbol. This
1453 happens when statically linking PIC code, or when
1454 using -Bsymbolic. */
1455 break;
1458 if (splt == NULL)
1460 splt = bfd_get_section_by_name (dynobj, ".plt");
1461 BFD_ASSERT (splt != NULL);
1464 relocation = (splt->output_section->vma
1465 + splt->output_offset
1466 + h->plt.offset);
1468 break;
1470 case R_386_32:
1471 case R_386_PC32:
1472 if (info->shared
1473 && (input_section->flags & SEC_ALLOC) != 0
1474 && (r_type != R_386_PC32
1475 || (h != NULL
1476 && h->dynindx != -1
1477 && (! info->symbolic
1478 || (h->elf_link_hash_flags
1479 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1481 Elf_Internal_Rel outrel;
1482 boolean skip, relocate;
1484 /* When generating a shared object, these relocations
1485 are copied into the output file to be resolved at run
1486 time. */
1488 if (sreloc == NULL)
1490 const char *name;
1492 name = (bfd_elf_string_from_elf_section
1493 (input_bfd,
1494 elf_elfheader (input_bfd)->e_shstrndx,
1495 elf_section_data (input_section)->rel_hdr.sh_name));
1496 if (name == NULL)
1497 return false;
1499 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1500 && strcmp (bfd_get_section_name (input_bfd,
1501 input_section),
1502 name + 4) == 0);
1504 sreloc = bfd_get_section_by_name (dynobj, name);
1505 BFD_ASSERT (sreloc != NULL);
1508 skip = false;
1510 if (elf_section_data (input_section)->stab_info == NULL)
1511 outrel.r_offset = rel->r_offset;
1512 else
1514 bfd_vma off;
1516 off = (_bfd_stab_section_offset
1517 (output_bfd, &elf_hash_table (info)->stab_info,
1518 input_section,
1519 &elf_section_data (input_section)->stab_info,
1520 rel->r_offset));
1521 if (off == (bfd_vma) -1)
1522 skip = true;
1523 outrel.r_offset = off;
1526 outrel.r_offset += (input_section->output_section->vma
1527 + input_section->output_offset);
1529 if (skip)
1531 memset (&outrel, 0, sizeof outrel);
1532 relocate = false;
1534 else if (r_type == R_386_PC32)
1536 BFD_ASSERT (h != NULL && h->dynindx != -1);
1537 relocate = false;
1538 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1540 else
1542 /* h->dynindx may be -1 if this symbol was marked to
1543 become local. */
1544 if (h == NULL
1545 || ((info->symbolic || h->dynindx == -1)
1546 && (h->elf_link_hash_flags
1547 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1549 relocate = true;
1550 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1552 else
1554 BFD_ASSERT (h->dynindx != -1);
1555 relocate = false;
1556 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1560 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1561 (((Elf32_External_Rel *)
1562 sreloc->contents)
1563 + sreloc->reloc_count));
1564 ++sreloc->reloc_count;
1566 /* If this reloc is against an external symbol, we do
1567 not want to fiddle with the addend. Otherwise, we
1568 need to include the symbol value so that it becomes
1569 an addend for the dynamic reloc. */
1570 if (! relocate)
1571 continue;
1574 break;
1576 default:
1577 break;
1580 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1581 contents, rel->r_offset,
1582 relocation, (bfd_vma) 0);
1584 if (r != bfd_reloc_ok)
1586 switch (r)
1588 default:
1589 case bfd_reloc_outofrange:
1590 abort ();
1591 case bfd_reloc_overflow:
1593 const char *name;
1595 if (h != NULL)
1596 name = h->root.root.string;
1597 else
1599 name = bfd_elf_string_from_elf_section (input_bfd,
1600 symtab_hdr->sh_link,
1601 sym->st_name);
1602 if (name == NULL)
1603 return false;
1604 if (*name == '\0')
1605 name = bfd_section_name (input_bfd, sec);
1607 if (! ((*info->callbacks->reloc_overflow)
1608 (info, name, howto->name, (bfd_vma) 0,
1609 input_bfd, input_section, rel->r_offset)))
1610 return false;
1612 break;
1617 return true;
1620 /* Finish up dynamic symbol handling. We set the contents of various
1621 dynamic sections here. */
1623 static boolean
1624 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1625 bfd *output_bfd;
1626 struct bfd_link_info *info;
1627 struct elf_link_hash_entry *h;
1628 Elf_Internal_Sym *sym;
1630 bfd *dynobj;
1632 dynobj = elf_hash_table (info)->dynobj;
1634 if (h->plt.offset != (bfd_vma) -1)
1636 asection *splt;
1637 asection *sgot;
1638 asection *srel;
1639 bfd_vma plt_index;
1640 bfd_vma got_offset;
1641 Elf_Internal_Rel rel;
1643 /* This symbol has an entry in the procedure linkage table. Set
1644 it up. */
1646 BFD_ASSERT (h->dynindx != -1);
1648 splt = bfd_get_section_by_name (dynobj, ".plt");
1649 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1650 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1651 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1653 /* Get the index in the procedure linkage table which
1654 corresponds to this symbol. This is the index of this symbol
1655 in all the symbols for which we are making plt entries. The
1656 first entry in the procedure linkage table is reserved. */
1657 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1659 /* Get the offset into the .got table of the entry that
1660 corresponds to this function. Each .got entry is 4 bytes.
1661 The first three are reserved. */
1662 got_offset = (plt_index + 3) * 4;
1664 /* Fill in the entry in the procedure linkage table. */
1665 if (! info->shared)
1667 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1668 PLT_ENTRY_SIZE);
1669 bfd_put_32 (output_bfd,
1670 (sgot->output_section->vma
1671 + sgot->output_offset
1672 + got_offset),
1673 splt->contents + h->plt.offset + 2);
1675 else
1677 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1678 PLT_ENTRY_SIZE);
1679 bfd_put_32 (output_bfd, got_offset,
1680 splt->contents + h->plt.offset + 2);
1683 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1684 splt->contents + h->plt.offset + 7);
1685 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1686 splt->contents + h->plt.offset + 12);
1688 /* Fill in the entry in the global offset table. */
1689 bfd_put_32 (output_bfd,
1690 (splt->output_section->vma
1691 + splt->output_offset
1692 + h->plt.offset
1693 + 6),
1694 sgot->contents + got_offset);
1696 /* Fill in the entry in the .rel.plt section. */
1697 rel.r_offset = (sgot->output_section->vma
1698 + sgot->output_offset
1699 + got_offset);
1700 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1701 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1702 ((Elf32_External_Rel *) srel->contents
1703 + plt_index));
1705 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1707 /* Mark the symbol as undefined, rather than as defined in
1708 the .plt section. Leave the value alone. */
1709 sym->st_shndx = SHN_UNDEF;
1713 if (h->got.offset != (bfd_vma) -1)
1715 asection *sgot;
1716 asection *srel;
1717 Elf_Internal_Rel rel;
1719 /* This symbol has an entry in the global offset table. Set it
1720 up. */
1722 sgot = bfd_get_section_by_name (dynobj, ".got");
1723 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1724 BFD_ASSERT (sgot != NULL && srel != NULL);
1726 rel.r_offset = (sgot->output_section->vma
1727 + sgot->output_offset
1728 + (h->got.offset &~ 1));
1730 /* If this is a -Bsymbolic link, and the symbol is defined
1731 locally, we just want to emit a RELATIVE reloc. Likewise if
1732 the symbol was forced to be local because of a version file.
1733 The entry in the global offset table will already have been
1734 initialized in the relocate_section function. */
1735 if (info->shared
1736 && (info->symbolic || h->dynindx == -1)
1737 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1738 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1739 else
1741 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1742 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1745 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1746 ((Elf32_External_Rel *) srel->contents
1747 + srel->reloc_count));
1748 ++srel->reloc_count;
1751 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1753 asection *s;
1754 Elf_Internal_Rel rel;
1756 /* This symbol needs a copy reloc. Set it up. */
1758 BFD_ASSERT (h->dynindx != -1
1759 && (h->root.type == bfd_link_hash_defined
1760 || h->root.type == bfd_link_hash_defweak));
1762 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1763 ".rel.bss");
1764 BFD_ASSERT (s != NULL);
1766 rel.r_offset = (h->root.u.def.value
1767 + h->root.u.def.section->output_section->vma
1768 + h->root.u.def.section->output_offset);
1769 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1770 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1771 ((Elf32_External_Rel *) s->contents
1772 + s->reloc_count));
1773 ++s->reloc_count;
1776 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1777 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1778 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1779 sym->st_shndx = SHN_ABS;
1781 return true;
1784 /* Finish up the dynamic sections. */
1786 static boolean
1787 elf_i386_finish_dynamic_sections (output_bfd, info)
1788 bfd *output_bfd;
1789 struct bfd_link_info *info;
1791 bfd *dynobj;
1792 asection *sgot;
1793 asection *sdyn;
1795 dynobj = elf_hash_table (info)->dynobj;
1797 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1798 BFD_ASSERT (sgot != NULL);
1799 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1801 if (elf_hash_table (info)->dynamic_sections_created)
1803 asection *splt;
1804 Elf32_External_Dyn *dyncon, *dynconend;
1806 BFD_ASSERT (sdyn != NULL);
1808 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1809 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1810 for (; dyncon < dynconend; dyncon++)
1812 Elf_Internal_Dyn dyn;
1813 const char *name;
1814 asection *s;
1816 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1818 switch (dyn.d_tag)
1820 default:
1821 break;
1823 case DT_PLTGOT:
1824 name = ".got";
1825 goto get_vma;
1826 case DT_JMPREL:
1827 name = ".rel.plt";
1828 get_vma:
1829 s = bfd_get_section_by_name (output_bfd, name);
1830 BFD_ASSERT (s != NULL);
1831 dyn.d_un.d_ptr = s->vma;
1832 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1833 break;
1835 case DT_PLTRELSZ:
1836 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1837 BFD_ASSERT (s != NULL);
1838 if (s->_cooked_size != 0)
1839 dyn.d_un.d_val = s->_cooked_size;
1840 else
1841 dyn.d_un.d_val = s->_raw_size;
1842 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1843 break;
1845 case DT_RELSZ:
1846 /* My reading of the SVR4 ABI indicates that the
1847 procedure linkage table relocs (DT_JMPREL) should be
1848 included in the overall relocs (DT_REL). This is
1849 what Solaris does. However, UnixWare can not handle
1850 that case. Therefore, we override the DT_RELSZ entry
1851 here to make it not include the JMPREL relocs. Since
1852 the linker script arranges for .rel.plt to follow all
1853 other relocation sections, we don't have to worry
1854 about changing the DT_REL entry. */
1855 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1856 if (s != NULL)
1858 if (s->_cooked_size != 0)
1859 dyn.d_un.d_val -= s->_cooked_size;
1860 else
1861 dyn.d_un.d_val -= s->_raw_size;
1863 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1864 break;
1868 /* Fill in the first entry in the procedure linkage table. */
1869 splt = bfd_get_section_by_name (dynobj, ".plt");
1870 if (splt && splt->_raw_size > 0)
1872 if (info->shared)
1873 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1874 else
1876 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1877 bfd_put_32 (output_bfd,
1878 sgot->output_section->vma + sgot->output_offset + 4,
1879 splt->contents + 2);
1880 bfd_put_32 (output_bfd,
1881 sgot->output_section->vma + sgot->output_offset + 8,
1882 splt->contents + 8);
1885 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1886 really seem like the right value. */
1887 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1891 /* Fill in the first three entries in the global offset table. */
1892 if (sgot->_raw_size > 0)
1894 if (sdyn == NULL)
1895 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1896 else
1897 bfd_put_32 (output_bfd,
1898 sdyn->output_section->vma + sdyn->output_offset,
1899 sgot->contents);
1900 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1901 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1904 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1906 return true;
1909 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1910 #define TARGET_LITTLE_NAME "elf32-i386"
1911 #define ELF_ARCH bfd_arch_i386
1912 #define ELF_MACHINE_CODE EM_386
1913 #define ELF_MAXPAGESIZE 0x1000
1914 #define elf_info_to_howto elf_i386_info_to_howto
1915 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1916 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1917 #define bfd_elf32_bfd_is_local_label_name \
1918 elf_i386_is_local_label_name
1919 #define elf_backend_create_dynamic_sections \
1920 _bfd_elf_create_dynamic_sections
1921 #define bfd_elf32_bfd_link_hash_table_create \
1922 elf_i386_link_hash_table_create
1923 #define elf_backend_check_relocs elf_i386_check_relocs
1924 #define elf_backend_adjust_dynamic_symbol \
1925 elf_i386_adjust_dynamic_symbol
1926 #define elf_backend_size_dynamic_sections \
1927 elf_i386_size_dynamic_sections
1928 #define elf_backend_relocate_section elf_i386_relocate_section
1929 #define elf_backend_finish_dynamic_symbol \
1930 elf_i386_finish_dynamic_symbol
1931 #define elf_backend_finish_dynamic_sections \
1932 elf_i386_finish_dynamic_sections
1933 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
1934 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
1936 #define elf_backend_can_gc_sections 1
1937 #define elf_backend_want_got_plt 1
1938 #define elf_backend_plt_readonly 1
1939 #define elf_backend_want_plt_sym 0
1940 #define elf_backend_got_header_size 12
1941 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
1943 #include "elf32-target.h"