1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 static reloc_howto_type
*elf_i386_reloc_type_lookup
27 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
28 static void elf_i386_info_to_howto
29 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
30 static void elf_i386_info_to_howto_rel
31 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
32 static boolean elf_i386_create_dynamic_sections
33 PARAMS ((bfd
*, struct bfd_link_info
*));
34 static boolean elf_i386_create_got_section
35 PARAMS ((bfd
*, struct bfd_link_info
*));
36 static boolean elf_i386_check_relocs
37 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
38 const Elf_Internal_Rela
*));
39 static boolean elf_i386_adjust_dynamic_symbol
40 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
41 static boolean elf_i386_size_dynamic_sections
42 PARAMS ((bfd
*, struct bfd_link_info
*));
43 static boolean elf_i386_relocate_section
44 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
45 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
46 static boolean elf_i386_finish_dynamic_symbol
47 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
49 static boolean elf_i386_finish_dynamic_sections
50 PARAMS ((bfd
*, struct bfd_link_info
*));
52 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
71 static CONST
char *CONST reloc_type_names
[] =
87 static reloc_howto_type elf_howto_table
[]=
89 HOWTO(R_386_NONE
, 0,0, 0,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_NONE", true,0x00000000,0x00000000,false),
90 HOWTO(R_386_32
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_32", true,0xffffffff,0xffffffff,false),
91 HOWTO(R_386_PC32
, 0,2,32,true, 0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_PC32", true,0xffffffff,0xffffffff,true),
92 HOWTO(R_386_GOT32
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
93 HOWTO(R_386_PLT32
, 0,2,32,true,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
94 HOWTO(R_386_COPY
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_COPY", true,0xffffffff,0xffffffff,false),
95 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),
96 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),
97 HOWTO(R_386_RELATIVE
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
98 HOWTO(R_386_GOTOFF
, 0,2,32,false,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
99 HOWTO(R_386_GOTPC
, 0,2,32,true,0,complain_overflow_bitfield
, bfd_elf_generic_reloc
,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
102 #ifdef DEBUG_GEN_RELOC
103 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
108 static reloc_howto_type
*
109 elf_i386_reloc_type_lookup (abfd
, code
)
111 bfd_reloc_code_real_type code
;
116 TRACE ("BFD_RELOC_NONE");
117 return &elf_howto_table
[ (int)R_386_NONE
];
120 TRACE ("BFD_RELOC_32");
121 return &elf_howto_table
[ (int)R_386_32
];
123 case BFD_RELOC_32_PCREL
:
124 TRACE ("BFD_RELOC_PC32");
125 return &elf_howto_table
[ (int)R_386_PC32
];
127 case BFD_RELOC_386_GOT32
:
128 TRACE ("BFD_RELOC_386_GOT32");
129 return &elf_howto_table
[ (int)R_386_GOT32
];
131 case BFD_RELOC_386_PLT32
:
132 TRACE ("BFD_RELOC_386_PLT32");
133 return &elf_howto_table
[ (int)R_386_PLT32
];
135 case BFD_RELOC_386_COPY
:
136 TRACE ("BFD_RELOC_386_COPY");
137 return &elf_howto_table
[ (int)R_386_COPY
];
139 case BFD_RELOC_386_GLOB_DAT
:
140 TRACE ("BFD_RELOC_386_GLOB_DAT");
141 return &elf_howto_table
[ (int)R_386_GLOB_DAT
];
143 case BFD_RELOC_386_JUMP_SLOT
:
144 TRACE ("BFD_RELOC_386_JUMP_SLOT");
145 return &elf_howto_table
[ (int)R_386_JUMP_SLOT
];
147 case BFD_RELOC_386_RELATIVE
:
148 TRACE ("BFD_RELOC_386_RELATIVE");
149 return &elf_howto_table
[ (int)R_386_RELATIVE
];
151 case BFD_RELOC_386_GOTOFF
:
152 TRACE ("BFD_RELOC_386_GOTOFF");
153 return &elf_howto_table
[ (int)R_386_GOTOFF
];
155 case BFD_RELOC_386_GOTPC
:
156 TRACE ("BFD_RELOC_386_GOTPC");
157 return &elf_howto_table
[ (int)R_386_GOTPC
];
168 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
171 Elf32_Internal_Rela
*dst
;
173 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_386_max
);
175 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
179 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
182 Elf32_Internal_Rel
*dst
;
184 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_386_max
);
186 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
189 /* Functions for the i386 ELF linker. */
191 /* The name of the dynamic interpreter. This is put in the .interp
194 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
196 /* The size in bytes of an entry in the procedure linkage table. */
198 #define PLT_ENTRY_SIZE 16
200 /* The first entry in an absolute procedure linkage table looks like
201 this. See the SVR4 ABI i386 supplement to see how this works. */
203 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
205 0xff, 0x35, /* pushl contents of address */
206 0, 0, 0, 0, /* replaced with address of .got + 4. */
207 0xff, 0x25, /* jmp indirect */
208 0, 0, 0, 0, /* replaced with address of .got + 8. */
209 0, 0, 0, 0 /* pad out to 16 bytes. */
212 /* Subsequent entries in an absolute procedure linkage table look like
215 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
217 0xff, 0x25, /* jmp indirect */
218 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
219 0x68, /* pushl immediate */
220 0, 0, 0, 0, /* replaced with offset into relocation table. */
221 0xe9, /* jmp relative */
222 0, 0, 0, 0 /* replaced with offset to start of .plt. */
225 /* The first entry in a PIC procedure linkage table look like this. */
227 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
229 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
230 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
231 0, 0, 0, 0 /* pad out to 16 bytes. */
234 /* Subsequent entries in a PIC procedure linkage table look like this. */
236 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
238 0xff, 0xa3, /* jmp *offset(%ebx) */
239 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
240 0x68, /* pushl immediate */
241 0, 0, 0, 0, /* replaced with offset into relocation table. */
242 0xe9, /* jmp relative */
243 0, 0, 0, 0 /* replaced with offset to start of .plt. */
246 /* Create dynamic sections when linking against a dynamic object. */
249 elf_i386_create_dynamic_sections (abfd
, info
)
251 struct bfd_link_info
*info
;
254 register asection
*s
;
256 /* We need to create .plt, .rel.plt, .got, .got.plt, .dynbss, and
257 .rel.bss sections. */
259 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
261 s
= bfd_make_section (abfd
, ".plt");
263 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
| SEC_CODE
)
264 || ! bfd_set_section_alignment (abfd
, s
, 2))
267 s
= bfd_make_section (abfd
, ".rel.plt");
269 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
270 || ! bfd_set_section_alignment (abfd
, s
, 2))
273 if (! elf_i386_create_got_section (abfd
, info
))
276 /* The .dynbss section is a place to put symbols which are defined
277 by dynamic objects, are referenced by regular objects, and are
278 not functions. We must allocate space for them in the process
279 image and use a R_386_COPY reloc to tell the dynamic linker to
280 initialize them at run time. The linker script puts the .dynbss
281 section into the .bss section of the final image. */
282 s
= bfd_make_section (abfd
, ".dynbss");
284 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
))
287 /* The .rel.bss section holds copy relocs. This section is not
288 normally needed. We need to create it here, though, so that the
289 linker will map it to an output section. We can't just create it
290 only if we need it, because we will not know whether we need it
291 until we have seen all the input files, and the first time the
292 main linker code calls BFD after examining all the input files
293 (size_dynamic_sections) the input sections have already been
294 mapped to the output sections. If the section turns out not to
295 be needed, we can discard it later. We will never need this
296 section when generating a shared object, since they do not use
300 s
= bfd_make_section (abfd
, ".rel.bss");
302 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
303 || ! bfd_set_section_alignment (abfd
, s
, 2))
310 /* Create the .got section to hold the global offset table, and the
311 .got.plt section to hold procedure linkage table GOT entries. The
312 linker script will put .got.plt into the output .got section. */
315 elf_i386_create_got_section (abfd
, info
)
317 struct bfd_link_info
*info
;
320 register asection
*s
;
321 struct elf_link_hash_entry
*h
;
323 /* This function may be called more than once. */
324 if (bfd_get_section_by_name (abfd
, ".got") != NULL
)
327 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
329 s
= bfd_make_section (abfd
, ".got");
331 || ! bfd_set_section_flags (abfd
, s
, flags
)
332 || ! bfd_set_section_alignment (abfd
, s
, 2))
335 s
= bfd_make_section (abfd
, ".got.plt");
337 || ! bfd_set_section_flags (abfd
, s
, flags
)
338 || ! bfd_set_section_alignment (abfd
, s
, 2))
341 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
342 .got.plt section, which will be placed at the start of the output
343 .got section. We don't do this in the linker script because we
344 don't want to define the symbol if we are not creating a global
347 if (! (_bfd_generic_link_add_one_symbol
348 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
, (bfd_vma
) 0,
349 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
350 (struct bfd_link_hash_entry
**) &h
)))
352 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
353 h
->type
= STT_OBJECT
;
356 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
359 /* The first three global offset table entries are reserved. */
360 s
->_raw_size
+= 3 * 4;
365 /* Look through the relocs for a section during the first phase, and
366 allocate space in the global offset table or procedure linkage
370 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
372 struct bfd_link_info
*info
;
374 const Elf_Internal_Rela
*relocs
;
377 Elf_Internal_Shdr
*symtab_hdr
;
378 struct elf_link_hash_entry
**sym_hashes
;
379 bfd_vma
*local_got_offsets
;
380 const Elf_Internal_Rela
*rel
;
381 const Elf_Internal_Rela
*rel_end
;
386 if (info
->relocateable
)
389 dynobj
= elf_hash_table (info
)->dynobj
;
390 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
391 sym_hashes
= elf_sym_hashes (abfd
);
392 local_got_offsets
= elf_local_got_offsets (abfd
);
398 rel_end
= relocs
+ sec
->reloc_count
;
399 for (rel
= relocs
; rel
< rel_end
; rel
++)
402 struct elf_link_hash_entry
*h
;
404 r_symndx
= ELF32_R_SYM (rel
->r_info
);
406 if (r_symndx
< symtab_hdr
->sh_info
)
409 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
411 /* Some relocs require a global offset table. */
414 switch (ELF32_R_TYPE (rel
->r_info
))
419 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
420 if (! elf_i386_create_got_section (dynobj
, info
))
429 switch (ELF32_R_TYPE (rel
->r_info
))
432 /* This symbol requires a global offset table entry. */
436 sgot
= bfd_get_section_by_name (dynobj
, ".got");
437 BFD_ASSERT (sgot
!= NULL
);
441 && (h
!= NULL
|| info
->shared
))
443 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
446 srelgot
= bfd_make_section (dynobj
, ".rel.got");
448 || ! bfd_set_section_flags (dynobj
, srelgot
,
454 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
461 if (h
->got_offset
!= (bfd_vma
) -1)
463 /* We have already allocated space in the .got. */
466 h
->got_offset
= sgot
->_raw_size
;
468 /* Make sure this symbol is output as a dynamic symbol. */
469 if (h
->dynindx
== -1)
471 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
475 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
479 /* This is a global offset table entry for a local
481 if (local_got_offsets
== NULL
)
486 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
487 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
488 if (local_got_offsets
== NULL
)
490 bfd_set_error (bfd_error_no_memory
);
493 elf_local_got_offsets (abfd
) = local_got_offsets
;
494 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
495 local_got_offsets
[i
] = (bfd_vma
) -1;
497 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
499 /* We have already allocated space in the .got. */
502 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
506 /* If we are generating a shared object, we need to
507 output a R_386_RELATIVE reloc so that the dynamic
508 linker can adjust this GOT entry. */
509 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
513 sgot
->_raw_size
+= 4;
518 /* This symbol requires a procedure linkage table entry. We
519 actually build the entry in adjust_dynamic_symbol,
520 because this might be a case of linking PIC code without
521 linking in any dynamic objects, in which case we don't
522 need to generate a procedure linkage table after all. */
524 /* If this is a local symbol, we resolve it directly without
525 creating a procedure linkage table entry. */
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
))
536 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
543 && (sec
->flags
& SEC_ALLOC
) != 0)
545 /* When creating a shared object, we must copy these
546 reloc types into the output file. We create a reloc
547 section in dynobj and make room for this reloc. */
552 name
= (elf_string_from_elf_section
554 elf_elfheader (abfd
)->e_shstrndx
,
555 elf_section_data (sec
)->rel_hdr
.sh_name
));
559 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
560 && strcmp (bfd_get_section_name (abfd
, sec
),
563 sreloc
= bfd_get_section_by_name (dynobj
, name
);
566 sreloc
= bfd_make_section (dynobj
, name
);
568 || ! bfd_set_section_flags (dynobj
, sreloc
,
574 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
579 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
592 /* Adjust a symbol defined by a dynamic object and referenced by a
593 regular object. The current definition is in some section of the
594 dynamic object, but we're not including those sections. We have to
595 change the definition to something the rest of the link can
599 elf_i386_adjust_dynamic_symbol (info
, h
)
600 struct bfd_link_info
*info
;
601 struct elf_link_hash_entry
*h
;
605 unsigned int power_of_two
;
607 dynobj
= elf_hash_table (info
)->dynobj
;
609 /* Make sure we know what is going on here. */
610 BFD_ASSERT (dynobj
!= NULL
611 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
612 || ((h
->elf_link_hash_flags
613 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
614 && (h
->elf_link_hash_flags
615 & ELF_LINK_HASH_REF_REGULAR
) != 0
616 && (h
->elf_link_hash_flags
617 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
619 /* If this is a function, put it in the procedure linkage table. We
620 will fill in the contents of the procedure linkage table later,
621 when we know the address of the .got section. */
622 if (h
->type
== STT_FUNC
623 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
625 if (! elf_hash_table (info
)->dynamic_sections_created
)
627 /* This case can occur if we saw a PLT32 reloc in an input
628 file, but none of the input files were dynamic objects.
629 In such a case, we don't actually need to build a
630 procedure linkage table, and we can just do a PC32 reloc
632 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
636 s
= bfd_get_section_by_name (dynobj
, ".plt");
637 BFD_ASSERT (s
!= NULL
);
639 /* If this is the first .plt entry, make room for the special
641 if (s
->_raw_size
== 0)
642 s
->_raw_size
+= PLT_ENTRY_SIZE
;
644 /* If this symbol is not defined in a regular file, and we are
645 not generating a shared library, then set the symbol to this
646 location in the .plt. This is required to make function
647 pointers compare as equal between the normal executable and
648 the shared library. */
650 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
652 h
->root
.u
.def
.section
= s
;
653 h
->root
.u
.def
.value
= s
->_raw_size
;
656 h
->plt_offset
= s
->_raw_size
;
658 /* Make room for this entry. */
659 s
->_raw_size
+= PLT_ENTRY_SIZE
;
661 /* We also need to make an entry in the .got.plt section, which
662 will be placed in the .got section by the linker script. */
664 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
665 BFD_ASSERT (s
!= NULL
);
668 /* We also need to make an entry in the .rel.plt section. */
670 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
671 BFD_ASSERT (s
!= NULL
);
672 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
677 /* If this is a weak symbol, and there is a real definition, the
678 processor independent code will have arranged for us to see the
679 real definition first, and we can just use the same value. */
680 if (h
->weakdef
!= NULL
)
682 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
683 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
684 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
685 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
689 /* This is a reference to a symbol defined by a dynamic object which
690 is not a function. */
692 /* If we are creating a shared library, we must presume that the
693 only references to the symbol are via the global offset table.
694 For such cases we need not do anything here; the relocations will
695 be handled correctly by relocate_section. */
699 /* We must allocate the symbol in our .dynbss section, which will
700 become part of the .bss section of the executable. There will be
701 an entry for this symbol in the .dynsym section. The dynamic
702 object will contain position independent code, so all references
703 from the dynamic object to this symbol will go through the global
704 offset table. The dynamic linker will use the .dynsym entry to
705 determine the address it must put in the global offset table, so
706 both the dynamic object and the regular object will refer to the
707 same memory location for the variable. */
709 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
710 BFD_ASSERT (s
!= NULL
);
712 /* If the symbol is currently defined in the .bss section of the
713 dynamic object, then it is OK to simply initialize it to zero.
714 If the symbol is in some other section, we must generate a
715 R_386_COPY reloc to tell the dynamic linker to copy the initial
716 value out of the dynamic object and into the runtime process
717 image. We need to remember the offset into the .rel.bss section
718 we are going to use. */
719 if ((h
->root
.u
.def
.section
->flags
& SEC_LOAD
) != 0)
723 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
724 BFD_ASSERT (srel
!= NULL
);
725 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
726 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
729 /* We need to figure out the alignment required for this symbol. I
730 have no idea how ELF linkers handle this. */
731 power_of_two
= bfd_log2 (h
->size
);
732 if (power_of_two
> 3)
735 /* Apply the required alignment. */
736 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
737 (bfd_size_type
) (1 << power_of_two
));
738 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
740 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
744 /* Define the symbol as being at this point in the section. */
745 h
->root
.u
.def
.section
= s
;
746 h
->root
.u
.def
.value
= s
->_raw_size
;
748 /* Increment the section size to make room for the symbol. */
749 s
->_raw_size
+= h
->size
;
754 /* Set the sizes of the dynamic sections. */
757 elf_i386_size_dynamic_sections (output_bfd
, info
)
759 struct bfd_link_info
*info
;
767 dynobj
= elf_hash_table (info
)->dynobj
;
768 BFD_ASSERT (dynobj
!= NULL
);
770 if (elf_hash_table (info
)->dynamic_sections_created
)
772 /* Set the contents of the .interp section to the interpreter. */
775 s
= bfd_get_section_by_name (dynobj
, ".interp");
776 BFD_ASSERT (s
!= NULL
);
777 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
778 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
783 /* We may have created entries in the .rel.got section.
784 However, if we are not creating the dynamic sections, we will
785 not actually use these entries. Reset the size of .rel.got,
786 which will cause it to get stripped from the output file
788 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
793 /* The check_relocs and adjust_dynamic_symbol entry points have
794 determined the sizes of the various dynamic sections. Allocate
799 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
804 if ((s
->flags
& SEC_IN_MEMORY
) == 0)
807 /* It's OK to base decisions on the section name, because none
808 of the dynobj section names depend upon the input files. */
809 name
= bfd_get_section_name (dynobj
, s
);
813 if (strcmp (name
, ".plt") == 0)
815 if (s
->_raw_size
== 0)
817 /* Strip this section if we don't need it; see the
823 /* Remember whether there is a PLT. */
827 else if (strncmp (name
, ".rel", 4) == 0)
829 if (s
->_raw_size
== 0)
831 /* If we don't need this section, strip it from the
832 output file. This is mostly to handle .rel.bss and
833 .rel.plt. We must create both sections in
834 create_dynamic_sections, because they must be created
835 before the linker maps input sections to output
836 sections. The linker does that before
837 adjust_dynamic_symbol is called, and it is that
838 function which decides whether anything needs to go
839 into these sections. */
846 /* Remember whether there are any reloc sections other
848 if (strcmp (name
, ".rel.plt") != 0)
851 /* If this relocation section applies to a read only
852 section, then we probably need a DT_TEXTREL entry. */
853 target
= bfd_get_section_by_name (output_bfd
, name
+ 4);
855 && (target
->flags
& SEC_READONLY
) != 0)
858 /* We use the reloc_count field as a counter if we need
859 to copy relocs into the output file. */
863 else if (strncmp (name
, ".got", 4) != 0)
865 /* It's not one of our sections, so don't allocate space. */
873 for (spp
= &s
->output_section
->owner
->sections
;
874 *spp
!= s
->output_section
;
877 *spp
= s
->output_section
->next
;
878 --s
->output_section
->owner
->section_count
;
883 /* Allocate memory for the section contents. */
884 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
885 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
887 bfd_set_error (bfd_error_no_memory
);
892 if (elf_hash_table (info
)->dynamic_sections_created
)
894 /* Add some entries to the .dynamic section. We fill in the
895 values later, in elf_i386_finish_dynamic_sections, but we
896 must add the entries now so that we get the correct size for
897 the .dynamic section. The DT_DEBUG entry is filled in by the
898 dynamic linker and used by the debugger. */
901 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
907 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
908 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
909 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
910 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
916 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
917 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
918 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
919 sizeof (Elf32_External_Rel
)))
925 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
933 /* Relocate an i386 ELF section. */
936 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
937 contents
, relocs
, local_syms
, local_sections
)
939 struct bfd_link_info
*info
;
941 asection
*input_section
;
943 Elf_Internal_Rela
*relocs
;
944 Elf_Internal_Sym
*local_syms
;
945 asection
**local_sections
;
948 Elf_Internal_Shdr
*symtab_hdr
;
949 struct elf_link_hash_entry
**sym_hashes
;
950 bfd_vma
*local_got_offsets
;
954 Elf_Internal_Rela
*rel
;
955 Elf_Internal_Rela
*relend
;
957 dynobj
= elf_hash_table (info
)->dynobj
;
958 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
959 sym_hashes
= elf_sym_hashes (input_bfd
);
960 local_got_offsets
= elf_local_got_offsets (input_bfd
);
967 relend
= relocs
+ input_section
->reloc_count
;
968 for (; rel
< relend
; rel
++)
971 reloc_howto_type
*howto
;
973 struct elf_link_hash_entry
*h
;
974 Elf_Internal_Sym
*sym
;
977 bfd_reloc_status_type r
;
980 r_type
= ELF32_R_TYPE (rel
->r_info
);
981 if (r_type
< 0 || r_type
>= (int) R_386_max
)
983 bfd_set_error (bfd_error_bad_value
);
986 howto
= elf_howto_table
+ r_type
;
988 r_symndx
= ELF32_R_SYM (rel
->r_info
);
990 if (info
->relocateable
)
992 /* This is a relocateable link. We don't have to change
993 anything, unless the reloc is against a section symbol,
994 in which case we have to adjust according to where the
995 section symbol winds up in the output section. */
996 if (r_symndx
< symtab_hdr
->sh_info
)
998 sym
= local_syms
+ r_symndx
;
999 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1003 sec
= local_sections
[r_symndx
];
1004 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1005 val
+= sec
->output_offset
+ sym
->st_value
;
1006 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1013 /* This is a final link. */
1019 if (r_symndx
< symtab_hdr
->sh_info
)
1021 sym
= local_syms
+ r_symndx
;
1022 sec
= local_sections
[r_symndx
];
1023 relocation
= (sec
->output_section
->vma
1024 + sec
->output_offset
1029 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1030 if (h
->root
.type
== bfd_link_hash_defined
1031 || h
->root
.type
== bfd_link_hash_defweak
)
1033 sec
= h
->root
.u
.def
.section
;
1034 if (r_type
== R_386_GOTPC
1035 || (r_type
== R_386_PLT32
1036 && h
->plt_offset
!= (bfd_vma
) -1)
1037 || (r_type
== R_386_GOT32
1038 && elf_hash_table (info
)->dynamic_sections_created
)
1040 && (r_type
== R_386_32
1041 || r_type
== R_386_PC32
)
1042 && (input_section
->flags
& SEC_ALLOC
) != 0))
1044 /* In these cases, we don't need the relocation
1045 value. We check specially because in some
1046 obscure cases sec->output_section will be NULL. */
1050 relocation
= (h
->root
.u
.def
.value
1051 + sec
->output_section
->vma
1052 + sec
->output_offset
);
1054 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1056 else if (info
->shared
)
1060 if (! ((*info
->callbacks
->undefined_symbol
)
1061 (info
, h
->root
.root
.string
, input_bfd
,
1062 input_section
, rel
->r_offset
)))
1071 /* Relocation is to the entry for this symbol in the global
1075 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1076 BFD_ASSERT (sgot
!= NULL
);
1083 off
= h
->got_offset
;
1084 BFD_ASSERT (off
!= (bfd_vma
) -1);
1086 if (! elf_hash_table (info
)->dynamic_sections_created
)
1088 /* This is actually a static link. We must
1089 initialize this entry in the global offset table.
1090 Since the offset must always be a multiple of 4,
1091 we use the least significant bit to record
1092 whether we have initialized it already.
1094 When doing a dynamic link, we create a .rel.got
1095 relocation entry to initialize the value. This
1096 is done in the finish_dynamic_symbol routine. */
1101 bfd_put_32 (output_bfd
, relocation
,
1102 sgot
->contents
+ off
);
1107 relocation
= sgot
->output_offset
+ off
;
1113 BFD_ASSERT (local_got_offsets
!= NULL
1114 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1116 off
= local_got_offsets
[r_symndx
];
1118 /* The offset must always be a multiple of 4. We use
1119 the least significant bit to record whether we have
1120 already generated the necessary reloc. */
1125 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1130 Elf_Internal_Rel outrel
;
1132 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1133 BFD_ASSERT (srelgot
!= NULL
);
1135 outrel
.r_offset
= (sgot
->output_section
->vma
1136 + sgot
->output_offset
1138 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1139 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1140 (((Elf32_External_Rel
*)
1142 + srelgot
->reloc_count
));
1143 ++srelgot
->reloc_count
;
1146 local_got_offsets
[r_symndx
] |= 1;
1149 relocation
= sgot
->output_offset
+ off
;
1155 /* Relocation is relative to the start of the global offset
1160 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1161 BFD_ASSERT (sgot
!= NULL
);
1164 /* Note that sgot->output_offset is not involved in this
1165 calculation. We always want the start of .got. If we
1166 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1167 permitted by the ABI, we might have to change this
1169 relocation
-= sgot
->output_section
->vma
;
1174 /* Use global offset table as symbol value. */
1178 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1179 BFD_ASSERT (sgot
!= NULL
);
1182 relocation
= sgot
->output_section
->vma
;
1187 /* Relocation is to the entry for this symbol in the
1188 procedure linkage table. */
1190 /* Resolve a PLT32 reloc again a local symbol directly,
1191 without using the procedure linkage table. */
1195 if (h
->plt_offset
== (bfd_vma
) -1)
1197 /* We didn't make a PLT entry for this symbol. This
1198 happens when statically linking PIC code. */
1204 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1205 BFD_ASSERT (splt
!= NULL
);
1208 relocation
= (splt
->output_section
->vma
1209 + splt
->output_offset
1217 && (input_section
->flags
& SEC_ALLOC
) != 0)
1219 Elf_Internal_Rel outrel
;
1221 /* When generating a shared object, these relocations
1222 are copied into the output file to be resolved at run
1227 shared_name
= (elf_string_from_elf_section
1229 elf_elfheader (input_bfd
)->e_shstrndx
,
1230 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1231 if (shared_name
== NULL
)
1234 BFD_ASSERT (strncmp (shared_name
, ".rel", 4) == 0
1235 && strcmp (bfd_get_section_name (input_bfd
,
1237 shared_name
+ 4) == 0);
1239 sreloc
= bfd_get_section_by_name (dynobj
, shared_name
);
1240 BFD_ASSERT (sreloc
!= NULL
);
1243 outrel
.r_offset
= (rel
->r_offset
1244 + input_section
->output_section
->vma
1245 + input_section
->output_offset
);
1246 if (r_type
== R_386_PC32
)
1250 if (! ((*info
->callbacks
->undefined_symbol
)
1251 (info
, shared_name
? shared_name
: sec
->name
, input_bfd
,
1252 input_section
, rel
->r_offset
)))
1253 bfd_set_error (bfd_error_bad_value
);
1257 BFD_ASSERT (h
->dynindx
!= -1);
1258 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_PC32
);
1264 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1267 BFD_ASSERT (h
->dynindx
!= (bfd_vma
) -1);
1268 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1272 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1273 (((Elf32_External_Rel
*)
1275 + sreloc
->reloc_count
));
1276 ++sreloc
->reloc_count
;
1278 /* If this reloc is against an external symbol, we do
1279 not want to fiddle with the addend. Otherwise, we
1280 need to include the symbol value so that it becomes
1281 an addend for the dynamic reloc. */
1292 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1293 contents
, rel
->r_offset
,
1294 relocation
, (bfd_vma
) 0);
1296 if (r
!= bfd_reloc_ok
)
1301 case bfd_reloc_outofrange
:
1303 case bfd_reloc_overflow
:
1308 name
= h
->root
.root
.string
;
1311 name
= elf_string_from_elf_section (input_bfd
,
1312 symtab_hdr
->sh_link
,
1317 name
= bfd_section_name (input_bfd
, sec
);
1319 if (! ((*info
->callbacks
->reloc_overflow
)
1320 (info
, name
, howto
->name
, (bfd_vma
) 0,
1321 input_bfd
, input_section
, rel
->r_offset
)))
1332 /* Finish up dynamic symbol handling. We set the contents of various
1333 dynamic sections here. */
1336 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1338 struct bfd_link_info
*info
;
1339 struct elf_link_hash_entry
*h
;
1340 Elf_Internal_Sym
*sym
;
1344 dynobj
= elf_hash_table (info
)->dynobj
;
1346 if (h
->plt_offset
!= (bfd_vma
) -1)
1353 Elf_Internal_Rel rel
;
1355 /* This symbol has an entry in the procedure linkage table. Set
1358 BFD_ASSERT (h
->dynindx
!= -1);
1360 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1361 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1362 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
1363 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1365 /* Get the index in the procedure linkage table which
1366 corresponds to this symbol. This is the index of this symbol
1367 in all the symbols for which we are making plt entries. The
1368 first entry in the procedure linkage table is reserved. */
1369 plt_index
= h
->plt_offset
/ PLT_ENTRY_SIZE
- 1;
1371 /* Get the offset into the .got table of the entry that
1372 corresponds to this function. Each .got entry is 4 bytes.
1373 The first three are reserved. */
1374 got_offset
= (plt_index
+ 3) * 4;
1376 /* Fill in the entry in the procedure linkage table. */
1379 memcpy (splt
->contents
+ h
->plt_offset
, elf_i386_plt_entry
,
1381 bfd_put_32 (output_bfd
,
1382 (sgot
->output_section
->vma
1383 + sgot
->output_offset
1385 splt
->contents
+ h
->plt_offset
+ 2);
1389 memcpy (splt
->contents
+ h
->plt_offset
, elf_i386_pic_plt_entry
,
1391 bfd_put_32 (output_bfd
, got_offset
,
1392 splt
->contents
+ h
->plt_offset
+ 2);
1395 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1396 splt
->contents
+ h
->plt_offset
+ 7);
1397 bfd_put_32 (output_bfd
, - (h
->plt_offset
+ PLT_ENTRY_SIZE
),
1398 splt
->contents
+ h
->plt_offset
+ 12);
1400 /* Fill in the entry in the global offset table. */
1401 bfd_put_32 (output_bfd
,
1402 (splt
->output_section
->vma
1403 + splt
->output_offset
1406 sgot
->contents
+ got_offset
);
1408 /* Fill in the entry in the .rel.plt section. */
1409 rel
.r_offset
= (sgot
->output_section
->vma
1410 + sgot
->output_offset
1412 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1413 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1414 ((Elf32_External_Rel
*) srel
->contents
1417 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1419 /* Mark the symbol as undefined, rather than as defined in
1420 the .plt section. Leave the value alone. */
1421 sym
->st_shndx
= SHN_UNDEF
;
1425 if (h
->got_offset
!= (bfd_vma
) -1)
1429 Elf_Internal_Rel rel
;
1431 /* This symbol has an entry in the global offset table. Set it
1434 BFD_ASSERT (h
->dynindx
!= -1);
1436 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1437 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
1438 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
1440 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got_offset
);
1442 rel
.r_offset
= (sgot
->output_section
->vma
1443 + sgot
->output_offset
1445 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
1446 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1447 ((Elf32_External_Rel
*) srel
->contents
1448 + srel
->reloc_count
));
1449 ++srel
->reloc_count
;
1452 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1455 Elf_Internal_Rel rel
;
1457 /* This symbol needs a copy reloc. Set it up. */
1459 BFD_ASSERT (h
->dynindx
!= -1
1460 && (h
->root
.type
== bfd_link_hash_defined
1461 || h
->root
.type
== bfd_link_hash_defweak
));
1463 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1465 BFD_ASSERT (s
!= NULL
);
1467 rel
.r_offset
= (h
->root
.u
.def
.value
1468 + h
->root
.u
.def
.section
->output_section
->vma
1469 + h
->root
.u
.def
.section
->output_offset
);
1470 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
1471 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1472 ((Elf32_External_Rel
*) s
->contents
1477 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1478 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1479 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1480 sym
->st_shndx
= SHN_ABS
;
1485 /* Finish up the dynamic sections. */
1488 elf_i386_finish_dynamic_sections (output_bfd
, info
)
1490 struct bfd_link_info
*info
;
1496 dynobj
= elf_hash_table (info
)->dynobj
;
1498 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1499 BFD_ASSERT (sgot
!= NULL
);
1500 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1502 if (elf_hash_table (info
)->dynamic_sections_created
)
1505 Elf32_External_Dyn
*dyncon
, *dynconend
;
1507 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1508 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1510 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1511 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1512 for (; dyncon
< dynconend
; dyncon
++)
1514 Elf_Internal_Dyn dyn
;
1518 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1531 s
= bfd_get_section_by_name (output_bfd
, name
);
1532 BFD_ASSERT (s
!= NULL
);
1533 dyn
.d_un
.d_ptr
= s
->vma
;
1534 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1538 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
1539 BFD_ASSERT (s
!= NULL
);
1540 if (s
->_cooked_size
!= 0)
1541 dyn
.d_un
.d_val
= s
->_cooked_size
;
1543 dyn
.d_un
.d_val
= s
->_raw_size
;
1544 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1548 /* My reading of the SVR4 ABI indicates that the
1549 procedure linkage table relocs (DT_JMPREL) should be
1550 included in the overall relocs (DT_REL). This is
1551 what Solaris does. However, UnixWare can not handle
1552 that case. Therefore, we override the DT_RELSZ entry
1553 here to make it not include the JMPREL relocs. Since
1554 the linker script arranges for .rel.plt to follow all
1555 other relocation sections, we don't have to worry
1556 about changing the DT_REL entry. */
1557 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
1560 if (s
->_cooked_size
!= 0)
1561 dyn
.d_un
.d_val
-= s
->_cooked_size
;
1563 dyn
.d_un
.d_val
-= s
->_raw_size
;
1565 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1570 /* Fill in the first entry in the procedure linkage table. */
1571 if (splt
->_raw_size
> 0)
1574 memcpy (splt
->contents
, elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
1577 memcpy (splt
->contents
, elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
1578 bfd_put_32 (output_bfd
,
1579 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
1580 splt
->contents
+ 2);
1581 bfd_put_32 (output_bfd
,
1582 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
1583 splt
->contents
+ 8);
1587 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1588 really seem like the right value. */
1589 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
1592 /* Fill in the first three entries in the global offset table. */
1593 if (sgot
->_raw_size
> 0)
1596 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1598 bfd_put_32 (output_bfd
,
1599 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1601 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1602 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1605 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1610 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1611 #define TARGET_LITTLE_NAME "elf32-i386"
1612 #define ELF_ARCH bfd_arch_i386
1613 #define ELF_MACHINE_CODE EM_386
1614 #define elf_info_to_howto elf_i386_info_to_howto
1615 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1616 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1617 #define ELF_MAXPAGESIZE 0x1000
1618 #define elf_backend_create_dynamic_sections \
1619 elf_i386_create_dynamic_sections
1620 #define elf_backend_check_relocs elf_i386_check_relocs
1621 #define elf_backend_adjust_dynamic_symbol \
1622 elf_i386_adjust_dynamic_symbol
1623 #define elf_backend_size_dynamic_sections \
1624 elf_i386_size_dynamic_sections
1625 #define elf_backend_relocate_section elf_i386_relocate_section
1626 #define elf_backend_finish_dynamic_symbol \
1627 elf_i386_finish_dynamic_symbol
1628 #define elf_backend_finish_dynamic_sections \
1629 elf_i386_finish_dynamic_sections
1631 #include "elf32-target.h"