1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 static reloc_howto_type
*elf_i386_reloc_type_lookup
28 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
29 static void elf_i386_info_to_howto
30 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
31 static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
33 static boolean elf_i386_is_local_label_name
PARAMS ((bfd
*, const char *));
34 static boolean elf_i386_grok_prstatus
35 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
36 static boolean elf_i386_grok_psinfo
37 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
38 static struct bfd_hash_entry
*link_hash_newfunc
39 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
40 static struct bfd_link_hash_table
*elf_i386_link_hash_table_create
42 static boolean create_got_section
PARAMS((bfd
*, struct bfd_link_info
*));
43 static boolean elf_i386_create_dynamic_sections
44 PARAMS((bfd
*, struct bfd_link_info
*));
45 static boolean elf_i386_check_relocs
46 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
47 const Elf_Internal_Rela
*));
48 static asection
*elf_i386_gc_mark_hook
49 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
50 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
51 static boolean elf_i386_gc_sweep_hook
52 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
53 const Elf_Internal_Rela
*));
54 static boolean elf_i386_adjust_dynamic_symbol
55 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
56 static boolean allocate_dynrelocs
57 PARAMS ((struct elf_link_hash_entry
*, PTR
));
58 static boolean readonly_dynrelocs
59 PARAMS ((struct elf_link_hash_entry
*, PTR
));
60 static boolean elf_i386_fake_sections
61 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, asection
*));
62 static boolean elf_i386_size_dynamic_sections
63 PARAMS ((bfd
*, struct bfd_link_info
*));
64 static boolean elf_i386_relocate_section
65 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
66 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
67 static boolean elf_i386_finish_dynamic_symbol
68 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
70 static enum elf_reloc_type_class elf_i386_reloc_type_class
71 PARAMS ((const Elf_Internal_Rela
*));
72 static boolean elf_i386_finish_dynamic_sections
73 PARAMS ((bfd
*, struct bfd_link_info
*));
75 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
79 static reloc_howto_type elf_howto_table
[]=
81 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
82 bfd_elf_generic_reloc
, "R_386_NONE",
83 true, 0x00000000, 0x00000000, false),
84 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
85 bfd_elf_generic_reloc
, "R_386_32",
86 true, 0xffffffff, 0xffffffff, false),
87 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
88 bfd_elf_generic_reloc
, "R_386_PC32",
89 true, 0xffffffff, 0xffffffff, true),
90 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
91 bfd_elf_generic_reloc
, "R_386_GOT32",
92 true, 0xffffffff, 0xffffffff, false),
93 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
94 bfd_elf_generic_reloc
, "R_386_PLT32",
95 true, 0xffffffff, 0xffffffff, true),
96 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_386_COPY",
98 true, 0xffffffff, 0xffffffff, false),
99 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
100 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
101 true, 0xffffffff, 0xffffffff, false),
102 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
104 true, 0xffffffff, 0xffffffff, false),
105 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_386_RELATIVE",
107 true, 0xffffffff, 0xffffffff, false),
108 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_386_GOTOFF",
110 true, 0xffffffff, 0xffffffff, false),
111 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
112 bfd_elf_generic_reloc
, "R_386_GOTPC",
113 true, 0xffffffff, 0xffffffff, true),
115 /* We have a gap in the reloc numbers here.
116 R_386_standard counts the number up to this point, and
117 R_386_ext_offset is the value to subtract from a reloc type of
118 R_386_16 thru R_386_PC8 to form an index into this table. */
119 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
120 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
122 /* The remaining relocs are a GNU extension. */
123 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_16",
125 true, 0xffff, 0xffff, false),
126 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_PC16",
128 true, 0xffff, 0xffff, true),
129 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_386_8",
131 true, 0xff, 0xff, false),
132 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_386_PC8",
134 true, 0xff, 0xff, true),
137 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
138 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
140 /* GNU extension to record C++ vtable hierarchy. */
141 HOWTO (R_386_GNU_VTINHERIT
, /* type */
143 2, /* size (0 = byte, 1 = short, 2 = long) */
145 false, /* pc_relative */
147 complain_overflow_dont
, /* complain_on_overflow */
148 NULL
, /* special_function */
149 "R_386_GNU_VTINHERIT", /* name */
150 false, /* partial_inplace */
155 /* GNU extension to record C++ vtable member usage. */
156 HOWTO (R_386_GNU_VTENTRY
, /* type */
158 2, /* size (0 = byte, 1 = short, 2 = long) */
160 false, /* pc_relative */
162 complain_overflow_dont
, /* complain_on_overflow */
163 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
164 "R_386_GNU_VTENTRY", /* name */
165 false, /* partial_inplace */
170 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
174 #ifdef DEBUG_GEN_RELOC
175 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
180 static reloc_howto_type
*
181 elf_i386_reloc_type_lookup (abfd
, code
)
182 bfd
*abfd ATTRIBUTE_UNUSED
;
183 bfd_reloc_code_real_type code
;
188 TRACE ("BFD_RELOC_NONE");
189 return &elf_howto_table
[(unsigned int) R_386_NONE
];
192 TRACE ("BFD_RELOC_32");
193 return &elf_howto_table
[(unsigned int) R_386_32
];
196 TRACE ("BFD_RELOC_CTOR");
197 return &elf_howto_table
[(unsigned int) R_386_32
];
199 case BFD_RELOC_32_PCREL
:
200 TRACE ("BFD_RELOC_PC32");
201 return &elf_howto_table
[(unsigned int) R_386_PC32
];
203 case BFD_RELOC_386_GOT32
:
204 TRACE ("BFD_RELOC_386_GOT32");
205 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
207 case BFD_RELOC_386_PLT32
:
208 TRACE ("BFD_RELOC_386_PLT32");
209 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
211 case BFD_RELOC_386_COPY
:
212 TRACE ("BFD_RELOC_386_COPY");
213 return &elf_howto_table
[(unsigned int) R_386_COPY
];
215 case BFD_RELOC_386_GLOB_DAT
:
216 TRACE ("BFD_RELOC_386_GLOB_DAT");
217 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
219 case BFD_RELOC_386_JUMP_SLOT
:
220 TRACE ("BFD_RELOC_386_JUMP_SLOT");
221 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
223 case BFD_RELOC_386_RELATIVE
:
224 TRACE ("BFD_RELOC_386_RELATIVE");
225 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
227 case BFD_RELOC_386_GOTOFF
:
228 TRACE ("BFD_RELOC_386_GOTOFF");
229 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
231 case BFD_RELOC_386_GOTPC
:
232 TRACE ("BFD_RELOC_386_GOTPC");
233 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
235 /* The remaining relocs are a GNU extension. */
237 TRACE ("BFD_RELOC_16");
238 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
240 case BFD_RELOC_16_PCREL
:
241 TRACE ("BFD_RELOC_16_PCREL");
242 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
245 TRACE ("BFD_RELOC_8");
246 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
248 case BFD_RELOC_8_PCREL
:
249 TRACE ("BFD_RELOC_8_PCREL");
250 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
252 case BFD_RELOC_VTABLE_INHERIT
:
253 TRACE ("BFD_RELOC_VTABLE_INHERIT");
254 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
257 case BFD_RELOC_VTABLE_ENTRY
:
258 TRACE ("BFD_RELOC_VTABLE_ENTRY");
259 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
271 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
272 bfd
*abfd ATTRIBUTE_UNUSED
;
273 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
274 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
280 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
281 bfd
*abfd ATTRIBUTE_UNUSED
;
283 Elf32_Internal_Rel
*dst
;
285 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
288 if ((indx
= r_type
) >= R_386_standard
289 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
290 >= R_386_ext
- R_386_standard
)
291 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
292 >= R_386_vt
- R_386_ext
))
294 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
295 bfd_archive_filename (abfd
), (int) r_type
);
296 indx
= (unsigned int) R_386_NONE
;
298 cache_ptr
->howto
= &elf_howto_table
[indx
];
301 /* Return whether a symbol name implies a local label. The UnixWare
302 2.1 cc generates temporary symbols that start with .X, so we
303 recognize them here. FIXME: do other SVR4 compilers also use .X?.
304 If so, we should move the .X recognition into
305 _bfd_elf_is_local_label_name. */
308 elf_i386_is_local_label_name (abfd
, name
)
312 if (name
[0] == '.' && name
[1] == 'X')
315 return _bfd_elf_is_local_label_name (abfd
, name
);
318 /* Support for core dump NOTE sections. */
320 elf_i386_grok_prstatus (abfd
, note
)
322 Elf_Internal_Note
*note
;
327 switch (note
->descsz
)
332 case 144: /* Linux/i386 */
334 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
337 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
346 /* Make a ".reg/999" section. */
347 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
348 raw_size
, note
->descpos
+ offset
);
352 elf_i386_grok_psinfo (abfd
, note
)
354 Elf_Internal_Note
*note
;
356 switch (note
->descsz
)
361 case 128: /* Linux/MIPS elf_prpsinfo */
362 elf_tdata (abfd
)->core_program
363 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
364 elf_tdata (abfd
)->core_command
365 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
368 /* Note that for some reason, a spurious space is tacked
369 onto the end of the args in some (at least one anyway)
370 implementations, so strip it off if it exists. */
373 char *command
= elf_tdata (abfd
)->core_command
;
374 int n
= strlen (command
);
376 if (0 < n
&& command
[n
- 1] == ' ')
377 command
[n
- 1] = '\0';
383 /* Functions for the i386 ELF linker.
385 In order to gain some understanding of code in this file without
386 knowing all the intricate details of the linker, note the
389 Functions named elf_i386_* are called by external routines, other
390 functions are only called locally. elf_i386_* functions appear
391 in this file more or less in the order in which they are called
392 from external routines. eg. elf_i386_check_relocs is called
393 early in the link process, elf_i386_finish_dynamic_sections is
394 one of the last functions. */
397 /* The name of the dynamic interpreter. This is put in the .interp
400 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
402 /* The size in bytes of an entry in the procedure linkage table. */
404 #define PLT_ENTRY_SIZE 16
406 /* The first entry in an absolute procedure linkage table looks like
407 this. See the SVR4 ABI i386 supplement to see how this works. */
409 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
411 0xff, 0x35, /* pushl contents of address */
412 0, 0, 0, 0, /* replaced with address of .got + 4. */
413 0xff, 0x25, /* jmp indirect */
414 0, 0, 0, 0, /* replaced with address of .got + 8. */
415 0, 0, 0, 0 /* pad out to 16 bytes. */
418 /* Subsequent entries in an absolute procedure linkage table look like
421 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
423 0xff, 0x25, /* jmp indirect */
424 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
425 0x68, /* pushl immediate */
426 0, 0, 0, 0, /* replaced with offset into relocation table. */
427 0xe9, /* jmp relative */
428 0, 0, 0, 0 /* replaced with offset to start of .plt. */
431 /* The first entry in a PIC procedure linkage table look like this. */
433 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
435 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
436 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
437 0, 0, 0, 0 /* pad out to 16 bytes. */
440 /* Subsequent entries in a PIC procedure linkage table look like this. */
442 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
444 0xff, 0xa3, /* jmp *offset(%ebx) */
445 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
446 0x68, /* pushl immediate */
447 0, 0, 0, 0, /* replaced with offset into relocation table. */
448 0xe9, /* jmp relative */
449 0, 0, 0, 0 /* replaced with offset to start of .plt. */
452 /* The i386 linker needs to keep track of the number of relocs that it
453 decides to copy as dynamic relocs in check_relocs for each symbol.
454 This is so that it can later discard them if they are found to be
455 unnecessary. We store the information in a field extending the
456 regular ELF linker hash table. */
458 struct elf_i386_dyn_relocs
460 struct elf_i386_dyn_relocs
*next
;
462 /* The input section of the reloc. */
465 /* Total number of relocs copied for the input section. */
468 /* Number of pc-relative relocs copied for the input section. */
469 bfd_size_type pc_count
;
472 /* i386 ELF linker hash entry. */
474 struct elf_i386_link_hash_entry
476 struct elf_link_hash_entry root
;
478 /* Track dynamic relocs copied for this symbol. */
479 struct elf_i386_dyn_relocs
*dyn_relocs
;
482 /* i386 ELF linker hash table. */
484 struct elf_i386_link_hash_table
486 struct elf_link_hash_table root
;
488 /* Short-cuts to get to dynamic linker sections. */
498 /* Get the i386 ELF linker hash table from a link_info structure. */
500 #define elf_i386_hash_table(p) \
501 ((struct elf_i386_link_hash_table *) ((p)->hash))
503 /* Create an entry in an i386 ELF linker hash table. */
505 static struct bfd_hash_entry
*
506 link_hash_newfunc (entry
, table
, string
)
507 struct bfd_hash_entry
*entry
;
508 struct bfd_hash_table
*table
;
511 struct elf_i386_link_hash_entry
*ret
=
512 (struct elf_i386_link_hash_entry
*) entry
;
514 /* Allocate the structure if it has not already been allocated by a
516 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
517 ret
= ((struct elf_i386_link_hash_entry
*)
518 bfd_hash_allocate (table
,
519 sizeof (struct elf_i386_link_hash_entry
)));
520 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
521 return (struct bfd_hash_entry
*) ret
;
523 /* Call the allocation method of the superclass. */
524 ret
= ((struct elf_i386_link_hash_entry
*)
525 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
527 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
529 ret
->dyn_relocs
= NULL
;
532 return (struct bfd_hash_entry
*) ret
;
535 /* Create an i386 ELF linker hash table. */
537 static struct bfd_link_hash_table
*
538 elf_i386_link_hash_table_create (abfd
)
541 struct elf_i386_link_hash_table
*ret
;
542 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
544 ret
= (struct elf_i386_link_hash_table
*) bfd_alloc (abfd
, amt
);
545 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
548 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
, link_hash_newfunc
))
550 bfd_release (abfd
, ret
);
562 return &ret
->root
.root
;
565 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
566 shortcuts to them in our hash table. */
569 create_got_section (dynobj
, info
)
571 struct bfd_link_info
*info
;
573 struct elf_i386_link_hash_table
*htab
;
575 if (! _bfd_elf_create_got_section (dynobj
, info
))
578 htab
= elf_i386_hash_table (info
);
579 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
580 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
581 if (!htab
->sgot
|| !htab
->sgotplt
)
584 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
585 if (htab
->srelgot
== NULL
586 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
587 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
588 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
590 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
595 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
596 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
600 elf_i386_create_dynamic_sections (dynobj
, info
)
602 struct bfd_link_info
*info
;
604 struct elf_i386_link_hash_table
*htab
;
606 htab
= elf_i386_hash_table (info
);
607 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
610 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
613 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
614 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
615 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
617 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
619 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
620 || (!info
->shared
&& !htab
->srelbss
))
626 /* Look through the relocs for a section during the first phase, and
627 allocate space in the global offset table or procedure linkage
631 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
633 struct bfd_link_info
*info
;
635 const Elf_Internal_Rela
*relocs
;
637 struct elf_i386_link_hash_table
*htab
;
639 Elf_Internal_Shdr
*symtab_hdr
;
640 struct elf_link_hash_entry
**sym_hashes
;
641 bfd_signed_vma
*local_got_refcounts
;
642 const Elf_Internal_Rela
*rel
;
643 const Elf_Internal_Rela
*rel_end
;
646 if (info
->relocateable
)
649 htab
= elf_i386_hash_table (info
);
650 dynobj
= htab
->root
.dynobj
;
651 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
652 sym_hashes
= elf_sym_hashes (abfd
);
653 local_got_refcounts
= elf_local_got_refcounts (abfd
);
657 rel_end
= relocs
+ sec
->reloc_count
;
658 for (rel
= relocs
; rel
< rel_end
; rel
++)
660 unsigned long r_symndx
;
661 struct elf_link_hash_entry
*h
;
663 r_symndx
= ELF32_R_SYM (rel
->r_info
);
665 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
667 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
668 bfd_archive_filename (abfd
),
673 if (r_symndx
< symtab_hdr
->sh_info
)
676 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
678 /* Some relocs require a global offset table. */
679 if (htab
->sgot
== NULL
)
681 switch (ELF32_R_TYPE (rel
->r_info
))
687 htab
->root
.dynobj
= dynobj
= abfd
;
688 if (!create_got_section (dynobj
, info
))
697 switch (ELF32_R_TYPE (rel
->r_info
))
700 /* This symbol requires a global offset table entry. */
703 if (h
->got
.refcount
== -1)
706 h
->got
.refcount
+= 1;
710 /* This is a global offset table entry for a local symbol. */
711 if (local_got_refcounts
== NULL
)
715 size
= symtab_hdr
->sh_info
;
716 size
*= sizeof (bfd_signed_vma
);
717 local_got_refcounts
= ((bfd_signed_vma
*)
718 bfd_alloc (abfd
, size
));
719 if (local_got_refcounts
== NULL
)
721 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
722 memset (local_got_refcounts
, -1, (size_t) size
);
724 if (local_got_refcounts
[r_symndx
] == -1)
725 local_got_refcounts
[r_symndx
] = 1;
727 local_got_refcounts
[r_symndx
] += 1;
732 /* This symbol requires a procedure linkage table entry. We
733 actually build the entry in adjust_dynamic_symbol,
734 because this might be a case of linking PIC code which is
735 never referenced by a dynamic object, in which case we
736 don't need to generate a procedure linkage table entry
739 /* If this is a local symbol, we resolve it directly without
740 creating a procedure linkage table entry. */
744 if (h
->plt
.refcount
== -1)
746 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
750 h
->plt
.refcount
+= 1;
755 if (h
!= NULL
&& !info
->shared
)
757 /* If this reloc is in a read-only section, we might
758 need a copy reloc. */
759 if ((sec
->flags
& SEC_READONLY
) != 0)
760 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
762 /* We may need a .plt entry if the function this reloc
763 refers to is in a shared lib. */
764 if (h
->plt
.refcount
== -1)
767 h
->plt
.refcount
+= 1;
770 /* If we are creating a shared library, and this is a reloc
771 against a global symbol, or a non PC relative reloc
772 against a local symbol, then we need to copy the reloc
773 into the shared library. However, if we are linking with
774 -Bsymbolic, we do not need to copy a reloc against a
775 global symbol which is defined in an object we are
776 including in the link (i.e., DEF_REGULAR is set). At
777 this point we have not seen all the input files, so it is
778 possible that DEF_REGULAR is not set now but will be set
779 later (it is never cleared). In case of a weak definition,
780 DEF_REGULAR may be cleared later by a strong definition in
781 a shared library. We account for that possibility below by
782 storing information in the relocs_copied field of the hash
783 table entry. A similar situation occurs when creating
784 shared libraries and symbol visibility changes render the
787 If on the other hand, we are creating an executable, we
788 may need to keep relocations for symbols satisfied by a
789 dynamic library if we manage to avoid copy relocs for the
792 && (sec
->flags
& SEC_ALLOC
) != 0
793 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
796 || h
->root
.type
== bfd_link_hash_defweak
797 || (h
->elf_link_hash_flags
798 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
800 && (sec
->flags
& SEC_ALLOC
) != 0
802 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
803 && (h
->root
.type
== bfd_link_hash_defweak
804 || (h
->elf_link_hash_flags
805 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
807 /* We must copy these reloc types into the output file.
808 Create a reloc section in dynobj and make room for
811 htab
->root
.dynobj
= dynobj
= abfd
;
817 name
= (bfd_elf_string_from_elf_section
819 elf_elfheader (abfd
)->e_shstrndx
,
820 elf_section_data (sec
)->rel_hdr
.sh_name
));
824 if (strncmp (name
, ".rel", 4) != 0
825 || strcmp (bfd_get_section_name (abfd
, sec
),
828 (*_bfd_error_handler
)
829 (_("%s: bad relocation section name `%s\'"),
830 bfd_archive_filename (abfd
), name
);
833 sreloc
= bfd_get_section_by_name (dynobj
, name
);
838 sreloc
= bfd_make_section (dynobj
, name
);
839 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
840 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
841 if ((sec
->flags
& SEC_ALLOC
) != 0)
842 flags
|= SEC_ALLOC
| SEC_LOAD
;
844 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
845 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
848 elf_section_data (sec
)->sreloc
= sreloc
;
851 /* If this is a global symbol, we count the number of
852 relocations we need for this symbol. */
855 struct elf_i386_link_hash_entry
*eh
;
856 struct elf_i386_dyn_relocs
*p
;
858 eh
= (struct elf_i386_link_hash_entry
*) h
;
861 if (p
== NULL
|| p
->sec
!= sec
)
863 p
= ((struct elf_i386_dyn_relocs
*)
864 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
867 p
->next
= eh
->dyn_relocs
;
875 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
880 /* Track dynamic relocs needed for local syms too. */
881 elf_section_data (sec
)->local_dynrel
+= 1;
887 /* This relocation describes the C++ object vtable hierarchy.
888 Reconstruct it for later use during GC. */
889 case R_386_GNU_VTINHERIT
:
890 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
894 /* This relocation describes which C++ vtable entries are actually
895 used. Record for later use during GC. */
896 case R_386_GNU_VTENTRY
:
897 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
909 /* Return the section that should be marked against GC for a given
913 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
915 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
916 Elf_Internal_Rela
*rel
;
917 struct elf_link_hash_entry
*h
;
918 Elf_Internal_Sym
*sym
;
922 switch (ELF32_R_TYPE (rel
->r_info
))
924 case R_386_GNU_VTINHERIT
:
925 case R_386_GNU_VTENTRY
:
929 switch (h
->root
.type
)
931 case bfd_link_hash_defined
:
932 case bfd_link_hash_defweak
:
933 return h
->root
.u
.def
.section
;
935 case bfd_link_hash_common
:
936 return h
->root
.u
.c
.p
->section
;
945 if (!(elf_bad_symtab (abfd
)
946 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
947 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
948 && sym
->st_shndx
!= SHN_COMMON
))
950 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
957 /* Update the got entry reference counts for the section being removed. */
960 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
962 struct bfd_link_info
*info
;
964 const Elf_Internal_Rela
*relocs
;
966 Elf_Internal_Shdr
*symtab_hdr
;
967 struct elf_link_hash_entry
**sym_hashes
;
968 bfd_signed_vma
*local_got_refcounts
;
969 const Elf_Internal_Rela
*rel
, *relend
;
970 unsigned long r_symndx
;
971 struct elf_link_hash_entry
*h
;
974 elf_section_data (sec
)->local_dynrel
= 0;
976 dynobj
= elf_hash_table (info
)->dynobj
;
980 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
981 sym_hashes
= elf_sym_hashes (abfd
);
982 local_got_refcounts
= elf_local_got_refcounts (abfd
);
984 relend
= relocs
+ sec
->reloc_count
;
985 for (rel
= relocs
; rel
< relend
; rel
++)
986 switch (ELF32_R_TYPE (rel
->r_info
))
991 r_symndx
= ELF32_R_SYM (rel
->r_info
);
992 if (r_symndx
>= symtab_hdr
->sh_info
)
994 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
995 if (h
->got
.refcount
> 0)
996 h
->got
.refcount
-= 1;
998 else if (local_got_refcounts
!= NULL
)
1000 if (local_got_refcounts
[r_symndx
] > 0)
1001 local_got_refcounts
[r_symndx
] -= 1;
1007 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1008 if (r_symndx
>= symtab_hdr
->sh_info
)
1010 struct elf_i386_link_hash_entry
*eh
;
1011 struct elf_i386_dyn_relocs
**pp
;
1012 struct elf_i386_dyn_relocs
*p
;
1014 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1016 if (!info
->shared
&& h
->plt
.refcount
> 0)
1017 h
->plt
.refcount
-= 1;
1019 eh
= (struct elf_i386_link_hash_entry
*) h
;
1021 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1024 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
1035 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1036 if (r_symndx
>= symtab_hdr
->sh_info
)
1038 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1039 if (h
->plt
.refcount
> 0)
1040 h
->plt
.refcount
-= 1;
1051 /* Adjust a symbol defined by a dynamic object and referenced by a
1052 regular object. The current definition is in some section of the
1053 dynamic object, but we're not including those sections. We have to
1054 change the definition to something the rest of the link can
1058 elf_i386_adjust_dynamic_symbol (info
, h
)
1059 struct bfd_link_info
*info
;
1060 struct elf_link_hash_entry
*h
;
1062 struct elf_i386_link_hash_table
*htab
;
1065 unsigned int power_of_two
;
1067 htab
= elf_i386_hash_table (info
);
1068 dynobj
= htab
->root
.dynobj
;
1070 /* If this is a function, put it in the procedure linkage table. We
1071 will fill in the contents of the procedure linkage table later,
1072 when we know the address of the .got section. */
1073 if (h
->type
== STT_FUNC
1074 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1076 if (h
->plt
.refcount
<= 0
1078 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1079 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
1081 /* This case can occur if we saw a PLT32 reloc in an input
1082 file, but the symbol was never referred to by a dynamic
1083 object, or if all references were garbage collected. In
1084 such a case, we don't actually need to build a procedure
1085 linkage table, and we can just do a PC32 reloc instead. */
1086 h
->plt
.refcount
= (bfd_vma
) -1;
1087 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1093 /* It's possible that we incorrectly decided a .plt reloc was
1094 needed for an R_386_PC32 reloc to a non-function sym in
1095 check_relocs. We can't decide accurately between function and
1096 non-function syms in check-relocs; Objects loaded later in
1097 the link may change h->type. So fix it now. */
1098 h
->plt
.refcount
= (bfd_vma
) -1;
1100 /* If this is a weak symbol, and there is a real definition, the
1101 processor independent code will have arranged for us to see the
1102 real definition first, and we can just use the same value. */
1103 if (h
->weakdef
!= NULL
)
1105 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1106 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1107 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1108 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1112 /* This is a reference to a symbol defined by a dynamic object which
1113 is not a function. */
1115 /* If we are creating a shared library, we must presume that the
1116 only references to the symbol are via the global offset table.
1117 For such cases we need not do anything here; the relocations will
1118 be handled correctly by relocate_section. */
1122 /* If there are no references to this symbol that do not use the
1123 GOT, we don't need to generate a copy reloc. */
1124 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1127 /* We must allocate the symbol in our .dynbss section, which will
1128 become part of the .bss section of the executable. There will be
1129 an entry for this symbol in the .dynsym section. The dynamic
1130 object will contain position independent code, so all references
1131 from the dynamic object to this symbol will go through the global
1132 offset table. The dynamic linker will use the .dynsym entry to
1133 determine the address it must put in the global offset table, so
1134 both the dynamic object and the regular object will refer to the
1135 same memory location for the variable. */
1141 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1142 copy the initial value out of the dynamic object and into the
1143 runtime process image. We need to remember the offset into the
1144 .rel.bss section we are going to use. */
1145 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1149 srel
= htab
->srelbss
;
1152 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1153 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1156 /* We need to figure out the alignment required for this symbol. I
1157 have no idea how ELF linkers handle this. */
1158 power_of_two
= bfd_log2 (h
->size
);
1159 if (power_of_two
> 3)
1162 /* Apply the required alignment. */
1163 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1164 (bfd_size_type
) (1 << power_of_two
));
1165 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1167 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1171 /* Define the symbol as being at this point in the section. */
1172 h
->root
.u
.def
.section
= s
;
1173 h
->root
.u
.def
.value
= s
->_raw_size
;
1175 /* Increment the section size to make room for the symbol. */
1176 s
->_raw_size
+= h
->size
;
1181 /* This is the condition under which elf_i386_finish_dynamic_symbol
1182 will be called from elflink.h. If elflink.h doesn't call our
1183 finish_dynamic_symbol routine, we'll need to do something about
1184 initializing any .plt and .got entries in elf_i386_relocate_section. */
1185 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1187 && ((INFO)->shared \
1188 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1189 && ((H)->dynindx != -1 \
1190 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1192 /* Allocate space in .plt, .got and associated reloc sections for
1196 allocate_dynrelocs (h
, inf
)
1197 struct elf_link_hash_entry
*h
;
1200 struct bfd_link_info
*info
;
1201 struct elf_i386_link_hash_table
*htab
;
1203 struct elf_i386_link_hash_entry
*eh
;
1204 struct elf_i386_dyn_relocs
*p
;
1206 if (h
->root
.type
== bfd_link_hash_indirect
1207 || h
->root
.type
== bfd_link_hash_warning
)
1210 info
= (struct bfd_link_info
*) inf
;
1211 htab
= elf_i386_hash_table (info
);
1213 if (htab
->root
.dynamic_sections_created
1214 && h
->plt
.refcount
> 0)
1216 /* Make sure this symbol is output as a dynamic symbol.
1217 Undefined weak syms won't yet be marked as dynamic. */
1218 if (h
->dynindx
== -1
1219 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1221 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1229 /* If this is the first .plt entry, make room for the special
1231 if (s
->_raw_size
== 0)
1232 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1234 h
->plt
.offset
= s
->_raw_size
;
1236 /* If this symbol is not defined in a regular file, and we are
1237 not generating a shared library, then set the symbol to this
1238 location in the .plt. This is required to make function
1239 pointers compare as equal between the normal executable and
1240 the shared library. */
1242 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1244 h
->root
.u
.def
.section
= s
;
1245 h
->root
.u
.def
.value
= h
->plt
.offset
;
1248 /* Make room for this entry. */
1249 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1251 /* We also need to make an entry in the .got.plt section, which
1252 will be placed in the .got section by the linker script. */
1258 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1260 /* We also need to make an entry in the .rel.plt section. */
1264 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1269 h
->plt
.offset
= (bfd_vma
) -1;
1270 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1273 if (h
->got
.refcount
> 0)
1277 /* Make sure this symbol is output as a dynamic symbol.
1278 Undefined weak syms won't yet be marked as dynamic. */
1279 if (h
->dynindx
== -1
1280 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1282 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1287 h
->got
.offset
= s
->_raw_size
;
1289 dyn
= htab
->root
.dynamic_sections_created
;
1290 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1291 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1294 h
->got
.offset
= (bfd_vma
) -1;
1296 eh
= (struct elf_i386_link_hash_entry
*) h
;
1297 if (eh
->dyn_relocs
== NULL
)
1300 /* In the shared -Bsymbolic case, discard space allocated for
1301 dynamic pc-relative relocs against symbols which turn out to be
1302 defined in regular objects. For the normal shared case, discard
1303 space for relocs that have become local due to symbol visibility
1308 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1309 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1312 struct elf_i386_dyn_relocs
**pp
;
1314 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1316 p
->count
-= p
->pc_count
;
1327 /* For the non-shared case, discard space for relocs against
1328 symbols which turn out to need copy relocs or are not
1331 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1332 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1333 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1334 || (htab
->root
.dynamic_sections_created
1335 && (h
->root
.type
== bfd_link_hash_undefweak
1336 || h
->root
.type
== bfd_link_hash_undefined
))))
1338 /* Make sure this symbol is output as a dynamic symbol.
1339 Undefined weak syms won't yet be marked as dynamic. */
1340 if (h
->dynindx
== -1
1341 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1343 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1347 /* If that succeeded, we know we'll be keeping all the
1349 if (h
->dynindx
!= -1)
1353 eh
->dyn_relocs
= NULL
;
1358 /* Finally, allocate space. */
1359 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1361 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1362 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1368 /* Find any dynamic relocs that apply to read-only sections. */
1371 readonly_dynrelocs (h
, inf
)
1372 struct elf_link_hash_entry
*h
;
1375 struct elf_i386_link_hash_entry
*eh
;
1376 struct elf_i386_dyn_relocs
*p
;
1378 eh
= (struct elf_i386_link_hash_entry
*) h
;
1379 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1381 asection
*s
= p
->sec
->output_section
;
1383 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1385 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1387 info
->flags
|= DF_TEXTREL
;
1389 /* Not an error, just cut short the traversal. */
1396 /* Set the sizes of the dynamic sections. */
1399 elf_i386_size_dynamic_sections (output_bfd
, info
)
1400 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1401 struct bfd_link_info
*info
;
1403 struct elf_i386_link_hash_table
*htab
;
1409 htab
= elf_i386_hash_table (info
);
1410 dynobj
= htab
->root
.dynobj
;
1414 if (htab
->root
.dynamic_sections_created
)
1416 /* Set the contents of the .interp section to the interpreter. */
1419 s
= bfd_get_section_by_name (dynobj
, ".interp");
1422 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1423 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1427 /* Set up .got offsets for local syms, and space for local dynamic
1429 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1431 bfd_signed_vma
*local_got
;
1432 bfd_signed_vma
*end_local_got
;
1433 bfd_size_type locsymcount
;
1434 Elf_Internal_Shdr
*symtab_hdr
;
1437 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1440 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1442 bfd_size_type count
= elf_section_data (s
)->local_dynrel
;
1446 srel
= elf_section_data (s
)->sreloc
;
1447 srel
->_raw_size
+= count
* sizeof (Elf32_External_Rel
);
1451 local_got
= elf_local_got_refcounts (ibfd
);
1455 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1456 locsymcount
= symtab_hdr
->sh_info
;
1457 end_local_got
= local_got
+ locsymcount
;
1459 srel
= htab
->srelgot
;
1460 for (; local_got
< end_local_got
; ++local_got
)
1464 *local_got
= s
->_raw_size
;
1467 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1470 *local_got
= (bfd_vma
) -1;
1474 /* Allocate global sym .plt and .got entries, and space for global
1475 sym dynamic relocs. */
1476 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
1478 /* We now have determined the sizes of the various dynamic sections.
1479 Allocate memory for them. */
1481 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1483 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1488 || s
== htab
->sgotplt
)
1490 /* Strip this section if we don't need it; see the
1493 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1495 if (s
->_raw_size
== 0)
1497 /* If we don't need this section, strip it from the
1498 output file. This is mostly to handle .rel.bss and
1499 .rel.plt. We must create both sections in
1500 create_dynamic_sections, because they must be created
1501 before the linker maps input sections to output
1502 sections. The linker does that before
1503 adjust_dynamic_symbol is called, and it is that
1504 function which decides whether anything needs to go
1505 into these sections. */
1509 if (s
!= htab
->srelplt
)
1512 /* We use the reloc_count field as a counter if we need
1513 to copy relocs into the output file. */
1519 /* It's not one of our sections, so don't allocate space. */
1523 if (s
->_raw_size
== 0)
1525 _bfd_strip_section_from_output (info
, s
);
1529 /* Allocate memory for the section contents. We use bfd_zalloc
1530 here in case unused entries are not reclaimed before the
1531 section's contents are written out. This should not happen,
1532 but this way if it does, we get a R_386_NONE reloc instead
1534 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1535 if (s
->contents
== NULL
)
1539 if (htab
->root
.dynamic_sections_created
)
1541 /* Add some entries to the .dynamic section. We fill in the
1542 values later, in elf_i386_finish_dynamic_sections, but we
1543 must add the entries now so that we get the correct size for
1544 the .dynamic section. The DT_DEBUG entry is filled in by the
1545 dynamic linker and used by the debugger. */
1546 #define add_dynamic_entry(TAG, VAL) \
1547 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1551 if (!add_dynamic_entry (DT_DEBUG
, 0))
1555 if (htab
->splt
->_raw_size
!= 0)
1557 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1558 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1559 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1560 || !add_dynamic_entry (DT_JMPREL
, 0))
1566 if (!add_dynamic_entry (DT_REL
, 0)
1567 || !add_dynamic_entry (DT_RELSZ
, 0)
1568 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1571 /* If any dynamic relocs apply to a read-only section,
1572 then we need a DT_TEXTREL entry. */
1573 elf_link_hash_traverse (&htab
->root
, readonly_dynrelocs
, (PTR
) info
);
1575 if ((info
->flags
& DF_TEXTREL
) != 0)
1577 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1582 #undef add_dynamic_entry
1587 /* Set the correct type for an x86 ELF section. We do this by the
1588 section name, which is a hack, but ought to work. */
1591 elf_i386_fake_sections (abfd
, hdr
, sec
)
1592 bfd
*abfd ATTRIBUTE_UNUSED
;
1593 Elf32_Internal_Shdr
*hdr
;
1596 register const char *name
;
1598 name
= bfd_get_section_name (abfd
, sec
);
1600 /* This is an ugly, but unfortunately necessary hack that is
1601 needed when producing EFI binaries on x86. It tells
1602 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1603 containing ELF relocation info. We need this hack in order to
1604 be able to generate ELF binaries that can be translated into
1605 EFI applications (which are essentially COFF objects). Those
1606 files contain a COFF ".reloc" section inside an ELFNN object,
1607 which would normally cause BFD to segfault because it would
1608 attempt to interpret this section as containing relocation
1609 entries for section "oc". With this hack enabled, ".reloc"
1610 will be treated as a normal data section, which will avoid the
1611 segfault. However, you won't be able to create an ELFNN binary
1612 with a section named "oc" that needs relocations, but that's
1613 the kind of ugly side-effects you get when detecting section
1614 types based on their names... In practice, this limitation is
1615 unlikely to bite. */
1616 if (strcmp (name
, ".reloc") == 0)
1617 hdr
->sh_type
= SHT_PROGBITS
;
1622 /* Relocate an i386 ELF section. */
1625 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1626 contents
, relocs
, local_syms
, local_sections
)
1628 struct bfd_link_info
*info
;
1630 asection
*input_section
;
1632 Elf_Internal_Rela
*relocs
;
1633 Elf_Internal_Sym
*local_syms
;
1634 asection
**local_sections
;
1636 struct elf_i386_link_hash_table
*htab
;
1638 Elf_Internal_Shdr
*symtab_hdr
;
1639 struct elf_link_hash_entry
**sym_hashes
;
1640 bfd_vma
*local_got_offsets
;
1641 Elf_Internal_Rela
*rel
;
1642 Elf_Internal_Rela
*relend
;
1644 htab
= elf_i386_hash_table (info
);
1645 dynobj
= htab
->root
.dynobj
;
1646 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1647 sym_hashes
= elf_sym_hashes (input_bfd
);
1648 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1651 relend
= relocs
+ input_section
->reloc_count
;
1652 for (; rel
< relend
; rel
++)
1655 reloc_howto_type
*howto
;
1656 unsigned long r_symndx
;
1657 struct elf_link_hash_entry
*h
;
1658 Elf_Internal_Sym
*sym
;
1662 boolean unresolved_reloc
;
1663 bfd_reloc_status_type r
;
1666 r_type
= ELF32_R_TYPE (rel
->r_info
);
1667 if (r_type
== (int) R_386_GNU_VTINHERIT
1668 || r_type
== (int) R_386_GNU_VTENTRY
)
1671 if ((indx
= (unsigned) r_type
) >= R_386_standard
1672 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1673 >= R_386_ext
- R_386_standard
))
1675 bfd_set_error (bfd_error_bad_value
);
1678 howto
= elf_howto_table
+ indx
;
1680 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1682 if (info
->relocateable
)
1684 /* This is a relocateable link. We don't have to change
1685 anything, unless the reloc is against a section symbol,
1686 in which case we have to adjust according to where the
1687 section symbol winds up in the output section. */
1688 if (r_symndx
< symtab_hdr
->sh_info
)
1690 sym
= local_syms
+ r_symndx
;
1691 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1695 sec
= local_sections
[r_symndx
];
1696 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1697 val
+= sec
->output_offset
+ sym
->st_value
;
1698 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1705 /* This is a final link. */
1709 unresolved_reloc
= false;
1710 if (r_symndx
< symtab_hdr
->sh_info
)
1712 sym
= local_syms
+ r_symndx
;
1713 sec
= local_sections
[r_symndx
];
1714 relocation
= (sec
->output_section
->vma
1715 + sec
->output_offset
1720 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1721 while (h
->root
.type
== bfd_link_hash_indirect
1722 || h
->root
.type
== bfd_link_hash_warning
)
1723 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1726 if (h
->root
.type
== bfd_link_hash_defined
1727 || h
->root
.type
== bfd_link_hash_defweak
)
1729 sec
= h
->root
.u
.def
.section
;
1730 if (sec
->output_section
== NULL
)
1731 /* Set a flag that will be cleared later if we find a
1732 relocation value for this symbol. output_section
1733 is typically NULL for symbols satisfied by a shared
1735 unresolved_reloc
= true;
1737 relocation
= (h
->root
.u
.def
.value
1738 + sec
->output_section
->vma
1739 + sec
->output_offset
);
1741 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1743 else if (info
->shared
1744 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1745 && !info
->no_undefined
1746 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1750 if (! ((*info
->callbacks
->undefined_symbol
)
1751 (info
, h
->root
.root
.string
, input_bfd
,
1752 input_section
, rel
->r_offset
,
1753 (!info
->shared
|| info
->no_undefined
1754 || ELF_ST_VISIBILITY (h
->other
)))))
1762 /* Relocation is to the entry for this symbol in the global
1764 if (htab
->sgot
== NULL
)
1771 off
= h
->got
.offset
;
1772 dyn
= htab
->root
.dynamic_sections_created
;
1773 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1777 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1778 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1780 /* This is actually a static link, or it is a
1781 -Bsymbolic link and the symbol is defined
1782 locally, or the symbol was forced to be local
1783 because of a version file. We must initialize
1784 this entry in the global offset table. Since the
1785 offset must always be a multiple of 4, we use the
1786 least significant bit to record whether we have
1787 initialized it already.
1789 When doing a dynamic link, we create a .rel.got
1790 relocation entry to initialize the value. This
1791 is done in the finish_dynamic_symbol routine. */
1796 bfd_put_32 (output_bfd
, relocation
,
1797 htab
->sgot
->contents
+ off
);
1802 unresolved_reloc
= false;
1806 if (local_got_offsets
== NULL
)
1809 off
= local_got_offsets
[r_symndx
];
1811 /* The offset must always be a multiple of 4. We use
1812 the least significant bit to record whether we have
1813 already generated the necessary reloc. */
1818 bfd_put_32 (output_bfd
, relocation
,
1819 htab
->sgot
->contents
+ off
);
1824 Elf_Internal_Rel outrel
;
1826 srelgot
= htab
->srelgot
;
1827 if (srelgot
== NULL
)
1830 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1831 + htab
->sgot
->output_offset
1833 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1834 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1835 (((Elf32_External_Rel
*)
1837 + srelgot
->reloc_count
));
1838 ++srelgot
->reloc_count
;
1841 local_got_offsets
[r_symndx
] |= 1;
1845 if (off
>= (bfd_vma
) -2)
1848 relocation
= htab
->sgot
->output_offset
+ off
;
1852 /* Relocation is relative to the start of the global offset
1855 /* Note that sgot->output_offset is not involved in this
1856 calculation. We always want the start of .got. If we
1857 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1858 permitted by the ABI, we might have to change this
1860 relocation
-= htab
->sgot
->output_section
->vma
;
1864 /* Use global offset table as symbol value. */
1865 relocation
= htab
->sgot
->output_section
->vma
;
1866 unresolved_reloc
= false;
1870 /* Relocation is to the entry for this symbol in the
1871 procedure linkage table. */
1873 /* Resolve a PLT32 reloc against a local symbol directly,
1874 without using the procedure linkage table. */
1878 if (h
->plt
.offset
== (bfd_vma
) -1
1879 || htab
->splt
== NULL
)
1881 /* We didn't make a PLT entry for this symbol. This
1882 happens when statically linking PIC code, or when
1883 using -Bsymbolic. */
1887 relocation
= (htab
->splt
->output_section
->vma
1888 + htab
->splt
->output_offset
1890 unresolved_reloc
= false;
1896 && (input_section
->flags
& SEC_ALLOC
) != 0
1897 && (r_type
!= R_386_PC32
1900 && (! info
->symbolic
1901 || (h
->elf_link_hash_flags
1902 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1904 && (input_section
->flags
& SEC_ALLOC
) != 0
1907 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1908 && (((h
->elf_link_hash_flags
1909 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1910 && (h
->elf_link_hash_flags
1911 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1912 || h
->root
.type
== bfd_link_hash_undefweak
1913 || h
->root
.type
== bfd_link_hash_undefined
)))
1915 Elf_Internal_Rel outrel
;
1916 boolean skip
, relocate
;
1918 Elf32_External_Rel
*loc
;
1920 /* When generating a shared object, these relocations
1921 are copied into the output file to be resolved at run
1926 if (elf_section_data (input_section
)->stab_info
== NULL
)
1927 outrel
.r_offset
= rel
->r_offset
;
1930 off
= (_bfd_stab_section_offset
1931 (output_bfd
, htab
->root
.stab_info
, input_section
,
1932 &elf_section_data (input_section
)->stab_info
,
1934 if (off
== (bfd_vma
) -1)
1936 outrel
.r_offset
= off
;
1939 outrel
.r_offset
+= (input_section
->output_section
->vma
1940 + input_section
->output_offset
);
1944 memset (&outrel
, 0, sizeof outrel
);
1949 && (r_type
== R_386_PC32
1952 || (h
->elf_link_hash_flags
1953 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1957 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1961 /* This symbol is local, or marked to become local. */
1963 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1966 sreloc
= elf_section_data (input_section
)->sreloc
;
1970 loc
= ((Elf32_External_Rel
*) sreloc
->contents
1971 + sreloc
->reloc_count
);
1972 sreloc
->reloc_count
+= 1;
1973 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1975 /* If this reloc is against an external symbol, we do
1976 not want to fiddle with the addend. Otherwise, we
1977 need to include the symbol value so that it becomes
1978 an addend for the dynamic reloc. */
1989 /* FIXME: Why do we allow debugging sections to escape this error?
1990 More importantly, why do we not emit dynamic relocs for
1991 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1992 If we had emitted the dynamic reloc, we could remove the
1994 if (unresolved_reloc
1996 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1997 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1998 (*_bfd_error_handler
)
1999 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2000 bfd_archive_filename (input_bfd
),
2001 bfd_get_section_name (input_bfd
, input_section
),
2002 (long) rel
->r_offset
,
2003 h
->root
.root
.string
);
2005 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2006 contents
, rel
->r_offset
,
2007 relocation
, (bfd_vma
) 0);
2014 case bfd_reloc_overflow
:
2019 name
= h
->root
.root
.string
;
2022 name
= bfd_elf_string_from_elf_section (input_bfd
,
2023 symtab_hdr
->sh_link
,
2028 name
= bfd_section_name (input_bfd
, sec
);
2030 if (! ((*info
->callbacks
->reloc_overflow
)
2031 (info
, name
, howto
->name
, (bfd_vma
) 0,
2032 input_bfd
, input_section
, rel
->r_offset
)))
2038 case bfd_reloc_outofrange
:
2047 /* Finish up dynamic symbol handling. We set the contents of various
2048 dynamic sections here. */
2051 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2053 struct bfd_link_info
*info
;
2054 struct elf_link_hash_entry
*h
;
2055 Elf_Internal_Sym
*sym
;
2057 struct elf_i386_link_hash_table
*htab
;
2060 htab
= elf_i386_hash_table (info
);
2061 dynobj
= htab
->root
.dynobj
;
2063 if (h
->plt
.offset
!= (bfd_vma
) -1)
2067 Elf_Internal_Rel rel
;
2069 /* This symbol has an entry in the procedure linkage table. Set
2072 if (h
->dynindx
== -1
2073 || htab
->splt
== NULL
2074 || htab
->sgotplt
== NULL
2075 || htab
->srelplt
== NULL
)
2078 /* Get the index in the procedure linkage table which
2079 corresponds to this symbol. This is the index of this symbol
2080 in all the symbols for which we are making plt entries. The
2081 first entry in the procedure linkage table is reserved. */
2082 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2084 /* Get the offset into the .got table of the entry that
2085 corresponds to this function. Each .got entry is 4 bytes.
2086 The first three are reserved. */
2087 got_offset
= (plt_index
+ 3) * 4;
2089 /* Fill in the entry in the procedure linkage table. */
2092 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2094 bfd_put_32 (output_bfd
,
2095 (htab
->sgotplt
->output_section
->vma
2096 + htab
->sgotplt
->output_offset
2098 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2102 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2104 bfd_put_32 (output_bfd
, got_offset
,
2105 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2108 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2109 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2110 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2111 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2113 /* Fill in the entry in the global offset table. */
2114 bfd_put_32 (output_bfd
,
2115 (htab
->splt
->output_section
->vma
2116 + htab
->splt
->output_offset
2119 htab
->sgotplt
->contents
+ got_offset
);
2121 /* Fill in the entry in the .rel.plt section. */
2122 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2123 + htab
->sgotplt
->output_offset
2125 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2126 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2127 ((Elf32_External_Rel
*) htab
->srelplt
->contents
2130 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2132 /* Mark the symbol as undefined, rather than as defined in
2133 the .plt section. Leave the value alone. */
2134 sym
->st_shndx
= SHN_UNDEF
;
2138 if (h
->got
.offset
!= (bfd_vma
) -1)
2140 Elf_Internal_Rel rel
;
2142 /* This symbol has an entry in the global offset table. Set it
2145 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2148 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2149 + htab
->sgot
->output_offset
2150 + (h
->got
.offset
& ~(bfd_vma
) 1));
2152 /* If this is a static link, or it is a -Bsymbolic link and the
2153 symbol is defined locally or was forced to be local because
2154 of a version file, we just want to emit a RELATIVE reloc.
2155 The entry in the global offset table will already have been
2156 initialized in the relocate_section function. */
2160 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2161 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2163 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2164 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2168 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2169 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2170 htab
->sgot
->contents
+ h
->got
.offset
);
2171 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2174 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2175 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2176 + htab
->srelgot
->reloc_count
));
2177 ++htab
->srelgot
->reloc_count
;
2180 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2182 Elf_Internal_Rel rel
;
2184 /* This symbol needs a copy reloc. Set it up. */
2186 if (h
->dynindx
== -1
2187 || (h
->root
.type
!= bfd_link_hash_defined
2188 && h
->root
.type
!= bfd_link_hash_defweak
)
2189 || htab
->srelbss
== NULL
)
2192 rel
.r_offset
= (h
->root
.u
.def
.value
2193 + h
->root
.u
.def
.section
->output_section
->vma
2194 + h
->root
.u
.def
.section
->output_offset
);
2195 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2196 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2197 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2198 + htab
->srelbss
->reloc_count
));
2199 ++htab
->srelbss
->reloc_count
;
2202 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2203 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2204 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2205 sym
->st_shndx
= SHN_ABS
;
2210 /* Used to decide how to sort relocs in an optimal manner for the
2211 dynamic linker, before writing them out. */
2213 static enum elf_reloc_type_class
2214 elf_i386_reloc_type_class (rela
)
2215 const Elf_Internal_Rela
*rela
;
2217 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2219 case R_386_RELATIVE
:
2220 return reloc_class_relative
;
2221 case R_386_JUMP_SLOT
:
2222 return reloc_class_plt
;
2224 return reloc_class_copy
;
2226 return reloc_class_normal
;
2230 /* Finish up the dynamic sections. */
2233 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2235 struct bfd_link_info
*info
;
2237 struct elf_i386_link_hash_table
*htab
;
2241 htab
= elf_i386_hash_table (info
);
2242 dynobj
= htab
->root
.dynobj
;
2243 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2245 if (htab
->root
.dynamic_sections_created
)
2247 Elf32_External_Dyn
*dyncon
, *dynconend
;
2249 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2252 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2253 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2254 for (; dyncon
< dynconend
; dyncon
++)
2256 Elf_Internal_Dyn dyn
;
2258 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2266 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2267 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2271 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2272 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2276 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2277 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2279 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2280 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2284 /* My reading of the SVR4 ABI indicates that the
2285 procedure linkage table relocs (DT_JMPREL) should be
2286 included in the overall relocs (DT_REL). This is
2287 what Solaris does. However, UnixWare can not handle
2288 that case. Therefore, we override the DT_RELSZ entry
2289 here to make it not include the JMPREL relocs. Since
2290 the linker script arranges for .rel.plt to follow all
2291 other relocation sections, we don't have to worry
2292 about changing the DT_REL entry. */
2293 if (htab
->srelplt
!= NULL
)
2295 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2296 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2298 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2300 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2305 /* Fill in the first entry in the procedure linkage table. */
2306 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2309 memcpy (htab
->splt
->contents
,
2310 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2313 memcpy (htab
->splt
->contents
,
2314 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2315 bfd_put_32 (output_bfd
,
2316 (htab
->sgotplt
->output_section
->vma
2317 + htab
->sgotplt
->output_offset
2319 htab
->splt
->contents
+ 2);
2320 bfd_put_32 (output_bfd
,
2321 (htab
->sgotplt
->output_section
->vma
2322 + htab
->sgotplt
->output_offset
2324 htab
->splt
->contents
+ 8);
2327 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2328 really seem like the right value. */
2329 elf_section_data (htab
->splt
->output_section
)
2330 ->this_hdr
.sh_entsize
= 4;
2336 /* Fill in the first three entries in the global offset table. */
2337 if (htab
->sgotplt
->_raw_size
> 0)
2339 bfd_put_32 (output_bfd
,
2340 (sdyn
== NULL
? (bfd_vma
) 0
2341 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2342 htab
->sgotplt
->contents
);
2343 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2344 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2347 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2352 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2353 #define TARGET_LITTLE_NAME "elf32-i386"
2354 #define ELF_ARCH bfd_arch_i386
2355 #define ELF_MACHINE_CODE EM_386
2356 #define ELF_MAXPAGESIZE 0x1000
2358 #define elf_backend_can_gc_sections 1
2359 #define elf_backend_want_got_plt 1
2360 #define elf_backend_plt_readonly 1
2361 #define elf_backend_want_plt_sym 0
2362 #define elf_backend_got_header_size 12
2363 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2365 #define elf_info_to_howto elf_i386_info_to_howto
2366 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2368 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2369 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2370 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2372 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2373 #define elf_backend_check_relocs elf_i386_check_relocs
2374 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2375 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2376 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2377 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2378 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2379 #define elf_backend_relocate_section elf_i386_relocate_section
2380 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2381 #define elf_backend_fake_sections elf_i386_fake_sections
2382 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2383 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2384 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2386 #include "elf32-target.h"