1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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
34 PARAMS ((bfd
*, const char *));
35 static boolean elf_i386_grok_prstatus
36 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
37 static boolean elf_i386_grok_psinfo
38 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
39 static struct bfd_hash_entry
*link_hash_newfunc
40 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
41 static struct bfd_link_hash_table
*elf_i386_link_hash_table_create
43 static boolean create_got_section
44 PARAMS((bfd
*, struct bfd_link_info
*));
45 static boolean elf_i386_create_dynamic_sections
46 PARAMS((bfd
*, struct bfd_link_info
*));
47 static void elf_i386_copy_indirect_symbol
48 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
49 static int elf_i386_tls_transition
50 PARAMS ((struct bfd_link_info
*, int, int));
52 static boolean elf_i386_mkobject
54 static boolean elf_i386_object_p
56 static boolean elf_i386_check_relocs
57 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
58 const Elf_Internal_Rela
*));
59 static asection
*elf_i386_gc_mark_hook
60 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
61 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
62 static boolean elf_i386_gc_sweep_hook
63 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
64 const Elf_Internal_Rela
*));
65 static boolean elf_i386_adjust_dynamic_symbol
66 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
67 static boolean allocate_dynrelocs
68 PARAMS ((struct elf_link_hash_entry
*, PTR
));
69 static boolean readonly_dynrelocs
70 PARAMS ((struct elf_link_hash_entry
*, PTR
));
71 static boolean elf_i386_fake_sections
72 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, asection
*));
73 static boolean elf_i386_size_dynamic_sections
74 PARAMS ((bfd
*, struct bfd_link_info
*));
75 static bfd_vma dtpoff_base
76 PARAMS ((struct bfd_link_info
*));
78 PARAMS ((struct bfd_link_info
*, bfd_vma
));
79 static boolean elf_i386_relocate_section
80 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
81 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
82 static boolean elf_i386_finish_dynamic_symbol
83 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
85 static enum elf_reloc_type_class elf_i386_reloc_type_class
86 PARAMS ((const Elf_Internal_Rela
*));
87 static boolean elf_i386_finish_dynamic_sections
88 PARAMS ((bfd
*, struct bfd_link_info
*));
90 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
94 static reloc_howto_type elf_howto_table
[]=
96 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_386_NONE",
98 true, 0x00000000, 0x00000000, false),
99 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
100 bfd_elf_generic_reloc
, "R_386_32",
101 true, 0xffffffff, 0xffffffff, false),
102 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_386_PC32",
104 true, 0xffffffff, 0xffffffff, true),
105 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_386_GOT32",
107 true, 0xffffffff, 0xffffffff, false),
108 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_386_PLT32",
110 true, 0xffffffff, 0xffffffff, true),
111 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
112 bfd_elf_generic_reloc
, "R_386_COPY",
113 true, 0xffffffff, 0xffffffff, false),
114 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
115 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
116 true, 0xffffffff, 0xffffffff, false),
117 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
118 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
119 true, 0xffffffff, 0xffffffff, false),
120 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_RELATIVE",
122 true, 0xffffffff, 0xffffffff, false),
123 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_GOTOFF",
125 true, 0xffffffff, 0xffffffff, false),
126 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_GOTPC",
128 true, 0xffffffff, 0xffffffff, true),
130 /* We have a gap in the reloc numbers here.
131 R_386_standard counts the number up to this point, and
132 R_386_ext_offset is the value to subtract from a reloc type of
133 R_386_16 thru R_386_PC8 to form an index into this table. */
134 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
135 #define R_386_ext_offset ((unsigned int) R_386_TLS_LE - R_386_standard)
137 /* The remaining relocs are a GNU extension. */
138 HOWTO(R_386_TLS_LE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
139 bfd_elf_generic_reloc
, "R_386_TLS_LE",
140 true, 0xffffffff, 0xffffffff, false),
141 HOWTO(R_386_TLS_GD
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
142 bfd_elf_generic_reloc
, "R_386_TLS_GD",
143 true, 0xffffffff, 0xffffffff, false),
144 HOWTO(R_386_TLS_LDM
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
145 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
146 true, 0xffffffff, 0xffffffff, false),
147 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
148 bfd_elf_generic_reloc
, "R_386_16",
149 true, 0xffff, 0xffff, false),
150 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
151 bfd_elf_generic_reloc
, "R_386_PC16",
152 true, 0xffff, 0xffff, true),
153 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
154 bfd_elf_generic_reloc
, "R_386_8",
155 true, 0xff, 0xff, false),
156 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
157 bfd_elf_generic_reloc
, "R_386_PC8",
158 true, 0xff, 0xff, true),
160 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
161 #define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
162 /* These are common with Solaris TLS implementation. */
163 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
164 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
165 true, 0xffffffff, 0xffffffff, false),
166 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
167 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
168 true, 0xffffffff, 0xffffffff, false),
169 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
170 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
171 true, 0xffffffff, 0xffffffff, false),
172 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
173 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
174 true, 0xffffffff, 0xffffffff, false),
175 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
176 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
177 true, 0xffffffff, 0xffffffff, false),
178 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
179 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
180 true, 0xffffffff, 0xffffffff, false),
183 #define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
184 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
186 /* GNU extension to record C++ vtable hierarchy. */
187 HOWTO (R_386_GNU_VTINHERIT
, /* type */
189 2, /* size (0 = byte, 1 = short, 2 = long) */
191 false, /* pc_relative */
193 complain_overflow_dont
, /* complain_on_overflow */
194 NULL
, /* special_function */
195 "R_386_GNU_VTINHERIT", /* name */
196 false, /* partial_inplace */
199 false), /* pcrel_offset */
201 /* GNU extension to record C++ vtable member usage. */
202 HOWTO (R_386_GNU_VTENTRY
, /* type */
204 2, /* size (0 = byte, 1 = short, 2 = long) */
206 false, /* pc_relative */
208 complain_overflow_dont
, /* complain_on_overflow */
209 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
210 "R_386_GNU_VTENTRY", /* name */
211 false, /* partial_inplace */
214 false) /* pcrel_offset */
216 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
220 #ifdef DEBUG_GEN_RELOC
221 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
226 static reloc_howto_type
*
227 elf_i386_reloc_type_lookup (abfd
, code
)
228 bfd
*abfd ATTRIBUTE_UNUSED
;
229 bfd_reloc_code_real_type code
;
234 TRACE ("BFD_RELOC_NONE");
235 return &elf_howto_table
[(unsigned int) R_386_NONE
];
238 TRACE ("BFD_RELOC_32");
239 return &elf_howto_table
[(unsigned int) R_386_32
];
242 TRACE ("BFD_RELOC_CTOR");
243 return &elf_howto_table
[(unsigned int) R_386_32
];
245 case BFD_RELOC_32_PCREL
:
246 TRACE ("BFD_RELOC_PC32");
247 return &elf_howto_table
[(unsigned int) R_386_PC32
];
249 case BFD_RELOC_386_GOT32
:
250 TRACE ("BFD_RELOC_386_GOT32");
251 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
253 case BFD_RELOC_386_PLT32
:
254 TRACE ("BFD_RELOC_386_PLT32");
255 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
257 case BFD_RELOC_386_COPY
:
258 TRACE ("BFD_RELOC_386_COPY");
259 return &elf_howto_table
[(unsigned int) R_386_COPY
];
261 case BFD_RELOC_386_GLOB_DAT
:
262 TRACE ("BFD_RELOC_386_GLOB_DAT");
263 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
265 case BFD_RELOC_386_JUMP_SLOT
:
266 TRACE ("BFD_RELOC_386_JUMP_SLOT");
267 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
269 case BFD_RELOC_386_RELATIVE
:
270 TRACE ("BFD_RELOC_386_RELATIVE");
271 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
273 case BFD_RELOC_386_GOTOFF
:
274 TRACE ("BFD_RELOC_386_GOTOFF");
275 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
277 case BFD_RELOC_386_GOTPC
:
278 TRACE ("BFD_RELOC_386_GOTPC");
279 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
281 /* The remaining relocs are a GNU extension. */
282 case BFD_RELOC_386_TLS_LE
:
283 TRACE ("BFD_RELOC_386_TLS_LE");
284 return &elf_howto_table
[(unsigned int) R_386_TLS_LE
- R_386_ext_offset
];
286 case BFD_RELOC_386_TLS_GD
:
287 TRACE ("BFD_RELOC_386_TLS_GD");
288 return &elf_howto_table
[(unsigned int) R_386_TLS_GD
- R_386_ext_offset
];
290 case BFD_RELOC_386_TLS_LDM
:
291 TRACE ("BFD_RELOC_386_TLS_LDM");
292 return &elf_howto_table
[(unsigned int) R_386_TLS_LDM
- R_386_ext_offset
];
295 TRACE ("BFD_RELOC_16");
296 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
298 case BFD_RELOC_16_PCREL
:
299 TRACE ("BFD_RELOC_16_PCREL");
300 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
303 TRACE ("BFD_RELOC_8");
304 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
306 case BFD_RELOC_8_PCREL
:
307 TRACE ("BFD_RELOC_8_PCREL");
308 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
310 /* Common with Sun TLS implementation. */
311 case BFD_RELOC_386_TLS_LDO_32
:
312 TRACE ("BFD_RELOC_386_TLS_LDO_32");
313 return &elf_howto_table
[(unsigned int) R_386_TLS_LDO_32
- R_386_tls_offset
];
315 case BFD_RELOC_386_TLS_IE_32
:
316 TRACE ("BFD_RELOC_386_TLS_IE_32");
317 return &elf_howto_table
[(unsigned int) R_386_TLS_IE_32
- R_386_tls_offset
];
319 case BFD_RELOC_386_TLS_LE_32
:
320 TRACE ("BFD_RELOC_386_TLS_LE_32");
321 return &elf_howto_table
[(unsigned int) R_386_TLS_LE_32
- R_386_tls_offset
];
323 case BFD_RELOC_386_TLS_DTPMOD32
:
324 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
325 return &elf_howto_table
[(unsigned int) R_386_TLS_DTPMOD32
- R_386_tls_offset
];
327 case BFD_RELOC_386_TLS_DTPOFF32
:
328 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
329 return &elf_howto_table
[(unsigned int) R_386_TLS_DTPOFF32
- R_386_tls_offset
];
331 case BFD_RELOC_386_TLS_TPOFF32
:
332 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
333 return &elf_howto_table
[(unsigned int) R_386_TLS_TPOFF32
- R_386_tls_offset
];
335 case BFD_RELOC_VTABLE_INHERIT
:
336 TRACE ("BFD_RELOC_VTABLE_INHERIT");
337 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
340 case BFD_RELOC_VTABLE_ENTRY
:
341 TRACE ("BFD_RELOC_VTABLE_ENTRY");
342 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
354 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
355 bfd
*abfd ATTRIBUTE_UNUSED
;
356 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
357 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
363 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
364 bfd
*abfd ATTRIBUTE_UNUSED
;
366 Elf32_Internal_Rel
*dst
;
368 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
371 if ((indx
= r_type
) >= R_386_standard
372 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
373 >= R_386_ext
- R_386_standard
)
374 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
375 >= R_386_tls
- R_386_ext
)
376 && ((indx
= r_type
- R_386_vt_offset
) - R_386_tls
377 >= R_386_vt
- R_386_tls
))
379 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
380 bfd_archive_filename (abfd
), (int) r_type
);
381 indx
= (unsigned int) R_386_NONE
;
383 cache_ptr
->howto
= &elf_howto_table
[indx
];
386 /* Return whether a symbol name implies a local label. The UnixWare
387 2.1 cc generates temporary symbols that start with .X, so we
388 recognize them here. FIXME: do other SVR4 compilers also use .X?.
389 If so, we should move the .X recognition into
390 _bfd_elf_is_local_label_name. */
393 elf_i386_is_local_label_name (abfd
, name
)
397 if (name
[0] == '.' && name
[1] == 'X')
400 return _bfd_elf_is_local_label_name (abfd
, name
);
403 /* Support for core dump NOTE sections. */
405 elf_i386_grok_prstatus (abfd
, note
)
407 Elf_Internal_Note
*note
;
412 switch (note
->descsz
)
417 case 144: /* Linux/i386 */
419 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
422 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
431 /* Make a ".reg/999" section. */
432 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
433 raw_size
, note
->descpos
+ offset
);
437 elf_i386_grok_psinfo (abfd
, note
)
439 Elf_Internal_Note
*note
;
441 switch (note
->descsz
)
446 case 124: /* Linux/i386 elf_prpsinfo */
447 elf_tdata (abfd
)->core_program
448 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
449 elf_tdata (abfd
)->core_command
450 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
453 /* Note that for some reason, a spurious space is tacked
454 onto the end of the args in some (at least one anyway)
455 implementations, so strip it off if it exists. */
458 char *command
= elf_tdata (abfd
)->core_command
;
459 int n
= strlen (command
);
461 if (0 < n
&& command
[n
- 1] == ' ')
462 command
[n
- 1] = '\0';
468 /* Functions for the i386 ELF linker.
470 In order to gain some understanding of code in this file without
471 knowing all the intricate details of the linker, note the
474 Functions named elf_i386_* are called by external routines, other
475 functions are only called locally. elf_i386_* functions appear
476 in this file more or less in the order in which they are called
477 from external routines. eg. elf_i386_check_relocs is called
478 early in the link process, elf_i386_finish_dynamic_sections is
479 one of the last functions. */
482 /* The name of the dynamic interpreter. This is put in the .interp
485 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
487 /* The size in bytes of an entry in the procedure linkage table. */
489 #define PLT_ENTRY_SIZE 16
491 /* The first entry in an absolute procedure linkage table looks like
492 this. See the SVR4 ABI i386 supplement to see how this works. */
494 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
496 0xff, 0x35, /* pushl contents of address */
497 0, 0, 0, 0, /* replaced with address of .got + 4. */
498 0xff, 0x25, /* jmp indirect */
499 0, 0, 0, 0, /* replaced with address of .got + 8. */
500 0, 0, 0, 0 /* pad out to 16 bytes. */
503 /* Subsequent entries in an absolute procedure linkage table look like
506 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
508 0xff, 0x25, /* jmp indirect */
509 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
510 0x68, /* pushl immediate */
511 0, 0, 0, 0, /* replaced with offset into relocation table. */
512 0xe9, /* jmp relative */
513 0, 0, 0, 0 /* replaced with offset to start of .plt. */
516 /* The first entry in a PIC procedure linkage table look like this. */
518 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
520 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
521 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
522 0, 0, 0, 0 /* pad out to 16 bytes. */
525 /* Subsequent entries in a PIC procedure linkage table look like this. */
527 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
529 0xff, 0xa3, /* jmp *offset(%ebx) */
530 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
531 0x68, /* pushl immediate */
532 0, 0, 0, 0, /* replaced with offset into relocation table. */
533 0xe9, /* jmp relative */
534 0, 0, 0, 0 /* replaced with offset to start of .plt. */
537 /* The i386 linker needs to keep track of the number of relocs that it
538 decides to copy as dynamic relocs in check_relocs for each symbol.
539 This is so that it can later discard them if they are found to be
540 unnecessary. We store the information in a field extending the
541 regular ELF linker hash table. */
543 struct elf_i386_dyn_relocs
545 struct elf_i386_dyn_relocs
*next
;
547 /* The input section of the reloc. */
550 /* Total number of relocs copied for the input section. */
553 /* Number of pc-relative relocs copied for the input section. */
554 bfd_size_type pc_count
;
557 /* i386 ELF linker hash entry. */
559 struct elf_i386_link_hash_entry
561 struct elf_link_hash_entry elf
;
563 /* Track dynamic relocs copied for this symbol. */
564 struct elf_i386_dyn_relocs
*dyn_relocs
;
567 GOT_UNKNOWN
= 0, GOT_NORMAL
, GOT_TLS_GD
, GOT_TLS_IE
571 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
573 struct elf_i386_obj_tdata
575 struct elf_obj_tdata root
;
577 /* tls_type for each local got entry. */
578 char *local_got_tls_type
;
581 #define elf_i386_tdata(abfd) \
582 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
584 #define elf_i386_local_got_tls_type(abfd) \
585 (elf_i386_tdata (abfd)->local_got_tls_type)
588 elf_i386_mkobject (abfd
)
591 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
592 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
593 if (abfd
->tdata
.any
== NULL
)
599 elf_i386_object_p (abfd
)
602 /* Allocate our special target data. */
603 struct elf_i386_obj_tdata
*new_tdata
;
604 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
605 new_tdata
= bfd_zalloc (abfd
, amt
);
606 if (new_tdata
== NULL
)
608 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
609 abfd
->tdata
.any
= new_tdata
;
613 /* i386 ELF linker hash table. */
615 struct elf_i386_link_hash_table
617 struct elf_link_hash_table elf
;
619 /* Short-cuts to get to dynamic linker sections. */
629 bfd_signed_vma refcount
;
633 /* Small local sym to section mapping cache. */
634 struct sym_sec_cache sym_sec
;
637 /* Get the i386 ELF linker hash table from a link_info structure. */
639 #define elf_i386_hash_table(p) \
640 ((struct elf_i386_link_hash_table *) ((p)->hash))
642 /* Create an entry in an i386 ELF linker hash table. */
644 static struct bfd_hash_entry
*
645 link_hash_newfunc (entry
, table
, string
)
646 struct bfd_hash_entry
*entry
;
647 struct bfd_hash_table
*table
;
650 /* Allocate the structure if it has not already been allocated by a
654 entry
= bfd_hash_allocate (table
,
655 sizeof (struct elf_i386_link_hash_entry
));
660 /* Call the allocation method of the superclass. */
661 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
664 struct elf_i386_link_hash_entry
*eh
;
666 eh
= (struct elf_i386_link_hash_entry
*) entry
;
667 eh
->dyn_relocs
= NULL
;
668 eh
->tls_type
= GOT_UNKNOWN
;
674 /* Create an i386 ELF linker hash table. */
676 static struct bfd_link_hash_table
*
677 elf_i386_link_hash_table_create (abfd
)
680 struct elf_i386_link_hash_table
*ret
;
681 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
683 ret
= (struct elf_i386_link_hash_table
*) bfd_malloc (amt
);
687 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
700 ret
->sym_sec
.abfd
= NULL
;
702 return &ret
->elf
.root
;
705 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
706 shortcuts to them in our hash table. */
709 create_got_section (dynobj
, info
)
711 struct bfd_link_info
*info
;
713 struct elf_i386_link_hash_table
*htab
;
715 if (! _bfd_elf_create_got_section (dynobj
, info
))
718 htab
= elf_i386_hash_table (info
);
719 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
720 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
721 if (!htab
->sgot
|| !htab
->sgotplt
)
724 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
725 if (htab
->srelgot
== NULL
726 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
727 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
728 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
730 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
735 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
736 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
740 elf_i386_create_dynamic_sections (dynobj
, info
)
742 struct bfd_link_info
*info
;
744 struct elf_i386_link_hash_table
*htab
;
746 htab
= elf_i386_hash_table (info
);
747 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
750 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
753 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
754 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
755 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
757 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
759 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
760 || (!info
->shared
&& !htab
->srelbss
))
766 /* Copy the extra info we tack onto an elf_link_hash_entry. */
769 elf_i386_copy_indirect_symbol (dir
, ind
)
770 struct elf_link_hash_entry
*dir
, *ind
;
772 struct elf_i386_link_hash_entry
*edir
, *eind
;
774 edir
= (struct elf_i386_link_hash_entry
*) dir
;
775 eind
= (struct elf_i386_link_hash_entry
*) ind
;
777 if (eind
->dyn_relocs
!= NULL
)
779 if (edir
->dyn_relocs
!= NULL
)
781 struct elf_i386_dyn_relocs
**pp
;
782 struct elf_i386_dyn_relocs
*p
;
784 if (ind
->root
.type
== bfd_link_hash_indirect
)
787 /* Add reloc counts against the weak sym to the strong sym
788 list. Merge any entries against the same section. */
789 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
791 struct elf_i386_dyn_relocs
*q
;
793 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
794 if (q
->sec
== p
->sec
)
796 q
->pc_count
+= p
->pc_count
;
797 q
->count
+= p
->count
;
804 *pp
= edir
->dyn_relocs
;
807 edir
->dyn_relocs
= eind
->dyn_relocs
;
808 eind
->dyn_relocs
= NULL
;
811 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
815 elf_i386_tls_transition (info
, r_type
, is_local
)
816 struct bfd_link_info
*info
;
826 case R_386_TLS_IE_32
:
828 return R_386_TLS_LE_32
;
829 return R_386_TLS_IE_32
;
831 return R_386_TLS_LE_32
;
837 /* Look through the relocs for a section during the first phase, and
838 calculate needed space in the global offset table, procedure linkage
839 table, and dynamic reloc sections. */
842 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
844 struct bfd_link_info
*info
;
846 const Elf_Internal_Rela
*relocs
;
848 struct elf_i386_link_hash_table
*htab
;
849 Elf_Internal_Shdr
*symtab_hdr
;
850 struct elf_link_hash_entry
**sym_hashes
;
851 const Elf_Internal_Rela
*rel
;
852 const Elf_Internal_Rela
*rel_end
;
855 if (info
->relocateable
)
858 htab
= elf_i386_hash_table (info
);
859 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
860 sym_hashes
= elf_sym_hashes (abfd
);
864 rel_end
= relocs
+ sec
->reloc_count
;
865 for (rel
= relocs
; rel
< rel_end
; rel
++)
868 unsigned long r_symndx
;
869 struct elf_link_hash_entry
*h
;
871 r_symndx
= ELF32_R_SYM (rel
->r_info
);
872 r_type
= ELF32_R_TYPE (rel
->r_info
);
874 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
876 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
877 bfd_archive_filename (abfd
),
882 if (r_symndx
< symtab_hdr
->sh_info
)
885 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
887 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
891 case R_386_TLS_IE_32
:
893 info
->flags
|= DF_STATIC_TLS
;
897 /* This symbol requires a global offset table entry. */
899 int tls_type
, old_tls_type
;
904 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
905 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
906 case R_386_TLS_IE_32
: tls_type
= GOT_TLS_IE
; break;
911 h
->got
.refcount
+= 1;
912 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
916 bfd_signed_vma
*local_got_refcounts
;
918 /* This is a global offset table entry for a local symbol. */
919 local_got_refcounts
= elf_local_got_refcounts (abfd
);
920 if (local_got_refcounts
== NULL
)
924 size
= symtab_hdr
->sh_info
;
925 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
926 local_got_refcounts
= ((bfd_signed_vma
*)
927 bfd_zalloc (abfd
, size
));
928 if (local_got_refcounts
== NULL
)
930 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
931 elf_i386_local_got_tls_type (abfd
)
932 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
934 local_got_refcounts
[r_symndx
] += 1;
935 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
938 /* If a TLS symbol is accessed using IE at least once,
939 there is no point to use dynamic model for it. */
940 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
941 && (old_tls_type
!= GOT_TLS_GD
|| tls_type
!= GOT_TLS_IE
))
943 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
944 tls_type
= GOT_TLS_IE
;
947 (*_bfd_error_handler
)
948 (_("%s: `%s' accessed both as normal and thread local symbol"),
949 bfd_archive_filename (abfd
), h
->root
.root
.string
);
954 if (old_tls_type
!= tls_type
)
957 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
959 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
967 if (htab
->sgot
== NULL
)
969 if (htab
->elf
.dynobj
== NULL
)
970 htab
->elf
.dynobj
= abfd
;
971 if (!create_got_section (htab
->elf
.dynobj
, info
))
977 htab
->tls_ldm_got
.refcount
+= 1;
981 /* This symbol requires a procedure linkage table entry. We
982 actually build the entry in adjust_dynamic_symbol,
983 because this might be a case of linking PIC code which is
984 never referenced by a dynamic object, in which case we
985 don't need to generate a procedure linkage table entry
988 /* If this is a local symbol, we resolve it directly without
989 creating a procedure linkage table entry. */
993 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
994 h
->plt
.refcount
+= 1;
999 if (h
!= NULL
&& !info
->shared
)
1001 /* If this reloc is in a read-only section, we might
1002 need a copy reloc. We can't check reliably at this
1003 stage whether the section is read-only, as input
1004 sections have not yet been mapped to output sections.
1005 Tentatively set the flag for now, and correct in
1006 adjust_dynamic_symbol. */
1007 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1009 /* We may need a .plt entry if the function this reloc
1010 refers to is in a shared lib. */
1011 h
->plt
.refcount
+= 1;
1014 /* If we are creating a shared library, and this is a reloc
1015 against a global symbol, or a non PC relative reloc
1016 against a local symbol, then we need to copy the reloc
1017 into the shared library. However, if we are linking with
1018 -Bsymbolic, we do not need to copy a reloc against a
1019 global symbol which is defined in an object we are
1020 including in the link (i.e., DEF_REGULAR is set). At
1021 this point we have not seen all the input files, so it is
1022 possible that DEF_REGULAR is not set now but will be set
1023 later (it is never cleared). In case of a weak definition,
1024 DEF_REGULAR may be cleared later by a strong definition in
1025 a shared library. We account for that possibility below by
1026 storing information in the relocs_copied field of the hash
1027 table entry. A similar situation occurs when creating
1028 shared libraries and symbol visibility changes render the
1031 If on the other hand, we are creating an executable, we
1032 may need to keep relocations for symbols satisfied by a
1033 dynamic library if we manage to avoid copy relocs for the
1036 && (sec
->flags
& SEC_ALLOC
) != 0
1037 && (r_type
!= R_386_PC32
1039 && (! info
->symbolic
1040 || h
->root
.type
== bfd_link_hash_defweak
1041 || (h
->elf_link_hash_flags
1042 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1044 && (sec
->flags
& SEC_ALLOC
) != 0
1046 && (h
->root
.type
== bfd_link_hash_defweak
1047 || (h
->elf_link_hash_flags
1048 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1050 struct elf_i386_dyn_relocs
*p
;
1051 struct elf_i386_dyn_relocs
**head
;
1053 /* We must copy these reloc types into the output file.
1054 Create a reloc section in dynobj and make room for
1060 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1061 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1063 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1067 if (strncmp (name
, ".rel", 4) != 0
1068 || strcmp (bfd_get_section_name (abfd
, sec
),
1071 (*_bfd_error_handler
)
1072 (_("%s: bad relocation section name `%s\'"),
1073 bfd_archive_filename (abfd
), name
);
1076 if (htab
->elf
.dynobj
== NULL
)
1077 htab
->elf
.dynobj
= abfd
;
1079 dynobj
= htab
->elf
.dynobj
;
1080 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1085 sreloc
= bfd_make_section (dynobj
, name
);
1086 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1087 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1088 if ((sec
->flags
& SEC_ALLOC
) != 0)
1089 flags
|= SEC_ALLOC
| SEC_LOAD
;
1091 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1092 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1095 elf_section_data (sec
)->sreloc
= sreloc
;
1098 /* If this is a global symbol, we count the number of
1099 relocations we need for this symbol. */
1102 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1106 /* Track dynamic relocs needed for local syms too.
1107 We really need local syms available to do this
1111 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1116 head
= ((struct elf_i386_dyn_relocs
**)
1117 &elf_section_data (s
)->local_dynrel
);
1121 if (p
== NULL
|| p
->sec
!= sec
)
1123 bfd_size_type amt
= sizeof *p
;
1124 p
= ((struct elf_i386_dyn_relocs
*)
1125 bfd_alloc (htab
->elf
.dynobj
, amt
));
1136 if (r_type
== R_386_PC32
)
1141 /* This relocation describes the C++ object vtable hierarchy.
1142 Reconstruct it for later use during GC. */
1143 case R_386_GNU_VTINHERIT
:
1144 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1148 /* This relocation describes which C++ vtable entries are actually
1149 used. Record for later use during GC. */
1150 case R_386_GNU_VTENTRY
:
1151 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1155 case R_386_TLS_LE_32
:
1159 (*_bfd_error_handler
) (_("%s: TLS local exec code cannot be linked into shared objects"),
1160 bfd_archive_filename (abfd
));
1173 /* Return the section that should be marked against GC for a given
1177 elf_i386_gc_mark_hook (sec
, info
, rel
, h
, sym
)
1179 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1180 Elf_Internal_Rela
*rel
;
1181 struct elf_link_hash_entry
*h
;
1182 Elf_Internal_Sym
*sym
;
1186 switch (ELF32_R_TYPE (rel
->r_info
))
1188 case R_386_GNU_VTINHERIT
:
1189 case R_386_GNU_VTENTRY
:
1193 switch (h
->root
.type
)
1195 case bfd_link_hash_defined
:
1196 case bfd_link_hash_defweak
:
1197 return h
->root
.u
.def
.section
;
1199 case bfd_link_hash_common
:
1200 return h
->root
.u
.c
.p
->section
;
1208 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1213 /* Update the got entry reference counts for the section being removed. */
1216 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1218 struct bfd_link_info
*info
;
1220 const Elf_Internal_Rela
*relocs
;
1222 Elf_Internal_Shdr
*symtab_hdr
;
1223 struct elf_link_hash_entry
**sym_hashes
;
1224 bfd_signed_vma
*local_got_refcounts
;
1225 const Elf_Internal_Rela
*rel
, *relend
;
1226 unsigned long r_symndx
;
1227 struct elf_link_hash_entry
*h
;
1229 elf_section_data (sec
)->local_dynrel
= NULL
;
1231 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1232 sym_hashes
= elf_sym_hashes (abfd
);
1233 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1235 relend
= relocs
+ sec
->reloc_count
;
1236 for (rel
= relocs
; rel
< relend
; rel
++)
1237 switch (elf_i386_tls_transition (info
, ELF32_R_TYPE (rel
->r_info
),
1238 ELF32_R_SYM (rel
->r_info
)
1239 >= symtab_hdr
->sh_info
))
1242 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1243 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1247 case R_386_TLS_IE_32
:
1249 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1250 if (r_symndx
>= symtab_hdr
->sh_info
)
1252 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1253 if (h
->got
.refcount
> 0)
1254 h
->got
.refcount
-= 1;
1256 else if (local_got_refcounts
!= NULL
)
1258 if (local_got_refcounts
[r_symndx
] > 0)
1259 local_got_refcounts
[r_symndx
] -= 1;
1265 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1266 if (r_symndx
>= symtab_hdr
->sh_info
)
1268 struct elf_i386_link_hash_entry
*eh
;
1269 struct elf_i386_dyn_relocs
**pp
;
1270 struct elf_i386_dyn_relocs
*p
;
1272 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1274 if (!info
->shared
&& h
->plt
.refcount
> 0)
1275 h
->plt
.refcount
-= 1;
1277 eh
= (struct elf_i386_link_hash_entry
*) h
;
1279 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1282 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
1293 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1294 if (r_symndx
>= symtab_hdr
->sh_info
)
1296 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1297 if (h
->plt
.refcount
> 0)
1298 h
->plt
.refcount
-= 1;
1309 /* Adjust a symbol defined by a dynamic object and referenced by a
1310 regular object. The current definition is in some section of the
1311 dynamic object, but we're not including those sections. We have to
1312 change the definition to something the rest of the link can
1316 elf_i386_adjust_dynamic_symbol (info
, h
)
1317 struct bfd_link_info
*info
;
1318 struct elf_link_hash_entry
*h
;
1320 struct elf_i386_link_hash_table
*htab
;
1321 struct elf_i386_link_hash_entry
* eh
;
1322 struct elf_i386_dyn_relocs
*p
;
1324 unsigned int power_of_two
;
1326 /* If this is a function, put it in the procedure linkage table. We
1327 will fill in the contents of the procedure linkage table later,
1328 when we know the address of the .got section. */
1329 if (h
->type
== STT_FUNC
1330 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1332 if (h
->plt
.refcount
<= 0
1334 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1335 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1336 && h
->root
.type
!= bfd_link_hash_undefweak
1337 && h
->root
.type
!= bfd_link_hash_undefined
))
1339 /* This case can occur if we saw a PLT32 reloc in an input
1340 file, but the symbol was never referred to by a dynamic
1341 object, or if all references were garbage collected. In
1342 such a case, we don't actually need to build a procedure
1343 linkage table, and we can just do a PC32 reloc instead. */
1344 h
->plt
.offset
= (bfd_vma
) -1;
1345 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1351 /* It's possible that we incorrectly decided a .plt reloc was
1352 needed for an R_386_PC32 reloc to a non-function sym in
1353 check_relocs. We can't decide accurately between function and
1354 non-function syms in check-relocs; Objects loaded later in
1355 the link may change h->type. So fix it now. */
1356 h
->plt
.offset
= (bfd_vma
) -1;
1358 /* If this is a weak symbol, and there is a real definition, the
1359 processor independent code will have arranged for us to see the
1360 real definition first, and we can just use the same value. */
1361 if (h
->weakdef
!= NULL
)
1363 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1364 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1365 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1366 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1370 /* This is a reference to a symbol defined by a dynamic object which
1371 is not a function. */
1373 /* If we are creating a shared library, we must presume that the
1374 only references to the symbol are via the global offset table.
1375 For such cases we need not do anything here; the relocations will
1376 be handled correctly by relocate_section. */
1380 /* If there are no references to this symbol that do not use the
1381 GOT, we don't need to generate a copy reloc. */
1382 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1385 /* If -z nocopyreloc was given, we won't generate them either. */
1386 if (info
->nocopyreloc
)
1388 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1392 eh
= (struct elf_i386_link_hash_entry
*) h
;
1393 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1395 s
= p
->sec
->output_section
;
1396 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1400 /* If we didn't find any dynamic relocs in read-only sections, then
1401 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1404 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1408 /* We must allocate the symbol in our .dynbss section, which will
1409 become part of the .bss section of the executable. There will be
1410 an entry for this symbol in the .dynsym section. The dynamic
1411 object will contain position independent code, so all references
1412 from the dynamic object to this symbol will go through the global
1413 offset table. The dynamic linker will use the .dynsym entry to
1414 determine the address it must put in the global offset table, so
1415 both the dynamic object and the regular object will refer to the
1416 same memory location for the variable. */
1418 htab
= elf_i386_hash_table (info
);
1420 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1421 copy the initial value out of the dynamic object and into the
1422 runtime process image. */
1423 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1425 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rel
);
1426 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1429 /* We need to figure out the alignment required for this symbol. I
1430 have no idea how ELF linkers handle this. */
1431 power_of_two
= bfd_log2 (h
->size
);
1432 if (power_of_two
> 3)
1435 /* Apply the required alignment. */
1437 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1438 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1440 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1444 /* Define the symbol as being at this point in the section. */
1445 h
->root
.u
.def
.section
= s
;
1446 h
->root
.u
.def
.value
= s
->_raw_size
;
1448 /* Increment the section size to make room for the symbol. */
1449 s
->_raw_size
+= h
->size
;
1454 /* This is the condition under which elf_i386_finish_dynamic_symbol
1455 will be called from elflink.h. If elflink.h doesn't call our
1456 finish_dynamic_symbol routine, we'll need to do something about
1457 initializing any .plt and .got entries in elf_i386_relocate_section. */
1458 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1460 && ((INFO)->shared \
1461 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1462 && ((H)->dynindx != -1 \
1463 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1465 /* Allocate space in .plt, .got and associated reloc sections for
1469 allocate_dynrelocs (h
, inf
)
1470 struct elf_link_hash_entry
*h
;
1473 struct bfd_link_info
*info
;
1474 struct elf_i386_link_hash_table
*htab
;
1475 struct elf_i386_link_hash_entry
*eh
;
1476 struct elf_i386_dyn_relocs
*p
;
1478 if (h
->root
.type
== bfd_link_hash_indirect
)
1481 if (h
->root
.type
== bfd_link_hash_warning
)
1482 /* When warning symbols are created, they **replace** the "real"
1483 entry in the hash table, thus we never get to see the real
1484 symbol in a hash traversal. So look at it now. */
1485 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1487 info
= (struct bfd_link_info
*) inf
;
1488 htab
= elf_i386_hash_table (info
);
1490 if (htab
->elf
.dynamic_sections_created
1491 && h
->plt
.refcount
> 0)
1493 /* Make sure this symbol is output as a dynamic symbol.
1494 Undefined weak syms won't yet be marked as dynamic. */
1495 if (h
->dynindx
== -1
1496 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1498 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1502 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1504 asection
*s
= htab
->splt
;
1506 /* If this is the first .plt entry, make room for the special
1508 if (s
->_raw_size
== 0)
1509 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1511 h
->plt
.offset
= s
->_raw_size
;
1513 /* If this symbol is not defined in a regular file, and we are
1514 not generating a shared library, then set the symbol to this
1515 location in the .plt. This is required to make function
1516 pointers compare as equal between the normal executable and
1517 the shared library. */
1519 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1521 h
->root
.u
.def
.section
= s
;
1522 h
->root
.u
.def
.value
= h
->plt
.offset
;
1525 /* Make room for this entry. */
1526 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1528 /* We also need to make an entry in the .got.plt section, which
1529 will be placed in the .got section by the linker script. */
1530 htab
->sgotplt
->_raw_size
+= 4;
1532 /* We also need to make an entry in the .rel.plt section. */
1533 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
1537 h
->plt
.offset
= (bfd_vma
) -1;
1538 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1543 h
->plt
.offset
= (bfd_vma
) -1;
1544 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1547 /* If R_386_TLS_IE_32 symbol is now local to the binary,
1548 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1549 if (h
->got
.refcount
> 0
1552 && elf_i386_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1553 h
->got
.offset
= (bfd_vma
) -1;
1554 else if (h
->got
.refcount
> 0)
1558 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1560 /* Make sure this symbol is output as a dynamic symbol.
1561 Undefined weak syms won't yet be marked as dynamic. */
1562 if (h
->dynindx
== -1
1563 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1565 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1570 h
->got
.offset
= s
->_raw_size
;
1572 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1573 if (tls_type
== GOT_TLS_GD
)
1575 dyn
= htab
->elf
.dynamic_sections_created
;
1576 /* R_386_TLS_IE_32 needs one dynamic relocation,
1577 R_386_TLS_GD needs one if local symbol and two if global. */
1578 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1579 || tls_type
== GOT_TLS_IE
)
1580 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1581 else if (tls_type
== GOT_TLS_GD
)
1582 htab
->srelgot
->_raw_size
+= 2 * sizeof (Elf32_External_Rel
);
1583 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1584 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1587 h
->got
.offset
= (bfd_vma
) -1;
1589 eh
= (struct elf_i386_link_hash_entry
*) h
;
1590 if (eh
->dyn_relocs
== NULL
)
1593 /* In the shared -Bsymbolic case, discard space allocated for
1594 dynamic pc-relative relocs against symbols which turn out to be
1595 defined in regular objects. For the normal shared case, discard
1596 space for pc-relative relocs that have become local due to symbol
1597 visibility changes. */
1601 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1602 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1605 struct elf_i386_dyn_relocs
**pp
;
1607 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1609 p
->count
-= p
->pc_count
;
1620 /* For the non-shared case, discard space for relocs against
1621 symbols which turn out to need copy relocs or are not
1624 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1625 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1626 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1627 || (htab
->elf
.dynamic_sections_created
1628 && (h
->root
.type
== bfd_link_hash_undefweak
1629 || h
->root
.type
== bfd_link_hash_undefined
))))
1631 /* Make sure this symbol is output as a dynamic symbol.
1632 Undefined weak syms won't yet be marked as dynamic. */
1633 if (h
->dynindx
== -1
1634 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1636 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1640 /* If that succeeded, we know we'll be keeping all the
1642 if (h
->dynindx
!= -1)
1646 eh
->dyn_relocs
= NULL
;
1651 /* Finally, allocate space. */
1652 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1654 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1655 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1661 /* Find any dynamic relocs that apply to read-only sections. */
1664 readonly_dynrelocs (h
, inf
)
1665 struct elf_link_hash_entry
*h
;
1668 struct elf_i386_link_hash_entry
*eh
;
1669 struct elf_i386_dyn_relocs
*p
;
1671 if (h
->root
.type
== bfd_link_hash_warning
)
1672 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1674 eh
= (struct elf_i386_link_hash_entry
*) h
;
1675 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1677 asection
*s
= p
->sec
->output_section
;
1679 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1681 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1683 info
->flags
|= DF_TEXTREL
;
1685 /* Not an error, just cut short the traversal. */
1692 /* Set the sizes of the dynamic sections. */
1695 elf_i386_size_dynamic_sections (output_bfd
, info
)
1696 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1697 struct bfd_link_info
*info
;
1699 struct elf_i386_link_hash_table
*htab
;
1705 htab
= elf_i386_hash_table (info
);
1706 dynobj
= htab
->elf
.dynobj
;
1710 if (htab
->elf
.dynamic_sections_created
)
1712 /* Set the contents of the .interp section to the interpreter. */
1715 s
= bfd_get_section_by_name (dynobj
, ".interp");
1718 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1719 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1723 /* Set up .got offsets for local syms, and space for local dynamic
1725 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1727 bfd_signed_vma
*local_got
;
1728 bfd_signed_vma
*end_local_got
;
1729 char *local_tls_type
;
1730 bfd_size_type locsymcount
;
1731 Elf_Internal_Shdr
*symtab_hdr
;
1734 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1737 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1739 struct elf_i386_dyn_relocs
*p
;
1741 for (p
= *((struct elf_i386_dyn_relocs
**)
1742 &elf_section_data (s
)->local_dynrel
);
1746 if (!bfd_is_abs_section (p
->sec
)
1747 && bfd_is_abs_section (p
->sec
->output_section
))
1749 /* Input section has been discarded, either because
1750 it is a copy of a linkonce section or due to
1751 linker script /DISCARD/, so we'll be discarding
1754 else if (p
->count
!= 0)
1756 srel
= elf_section_data (p
->sec
)->sreloc
;
1757 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1758 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1759 info
->flags
|= DF_TEXTREL
;
1764 local_got
= elf_local_got_refcounts (ibfd
);
1768 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1769 locsymcount
= symtab_hdr
->sh_info
;
1770 end_local_got
= local_got
+ locsymcount
;
1771 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1773 srel
= htab
->srelgot
;
1774 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1778 *local_got
= s
->_raw_size
;
1780 if (*local_tls_type
== GOT_TLS_GD
)
1783 || *local_tls_type
== GOT_TLS_GD
1784 || *local_tls_type
== GOT_TLS_IE
)
1785 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1788 *local_got
= (bfd_vma
) -1;
1792 if (htab
->tls_ldm_got
.refcount
> 0)
1794 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1796 htab
->tls_ldm_got
.offset
= htab
->sgot
->_raw_size
;
1797 htab
->sgot
->_raw_size
+= 8;
1798 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1801 htab
->tls_ldm_got
.offset
= -1;
1803 /* Allocate global sym .plt and .got entries, and space for global
1804 sym dynamic relocs. */
1805 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1807 /* We now have determined the sizes of the various dynamic sections.
1808 Allocate memory for them. */
1810 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1812 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1817 || s
== htab
->sgotplt
)
1819 /* Strip this section if we don't need it; see the
1822 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1824 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1827 /* We use the reloc_count field as a counter if we need
1828 to copy relocs into the output file. */
1833 /* It's not one of our sections, so don't allocate space. */
1837 if (s
->_raw_size
== 0)
1839 /* If we don't need this section, strip it from the
1840 output file. This is mostly to handle .rel.bss and
1841 .rel.plt. We must create both sections in
1842 create_dynamic_sections, because they must be created
1843 before the linker maps input sections to output
1844 sections. The linker does that before
1845 adjust_dynamic_symbol is called, and it is that
1846 function which decides whether anything needs to go
1847 into these sections. */
1849 _bfd_strip_section_from_output (info
, s
);
1853 /* Allocate memory for the section contents. We use bfd_zalloc
1854 here in case unused entries are not reclaimed before the
1855 section's contents are written out. This should not happen,
1856 but this way if it does, we get a R_386_NONE reloc instead
1858 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1859 if (s
->contents
== NULL
)
1863 if (htab
->elf
.dynamic_sections_created
)
1865 /* Add some entries to the .dynamic section. We fill in the
1866 values later, in elf_i386_finish_dynamic_sections, but we
1867 must add the entries now so that we get the correct size for
1868 the .dynamic section. The DT_DEBUG entry is filled in by the
1869 dynamic linker and used by the debugger. */
1870 #define add_dynamic_entry(TAG, VAL) \
1871 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1875 if (!add_dynamic_entry (DT_DEBUG
, 0))
1879 if (htab
->splt
->_raw_size
!= 0)
1881 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1882 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1883 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1884 || !add_dynamic_entry (DT_JMPREL
, 0))
1890 if (!add_dynamic_entry (DT_REL
, 0)
1891 || !add_dynamic_entry (DT_RELSZ
, 0)
1892 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1895 /* If any dynamic relocs apply to a read-only section,
1896 then we need a DT_TEXTREL entry. */
1897 if ((info
->flags
& DF_TEXTREL
) == 0)
1898 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1901 if ((info
->flags
& DF_TEXTREL
) != 0)
1903 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1908 #undef add_dynamic_entry
1913 /* Set the correct type for an x86 ELF section. We do this by the
1914 section name, which is a hack, but ought to work. */
1917 elf_i386_fake_sections (abfd
, hdr
, sec
)
1918 bfd
*abfd ATTRIBUTE_UNUSED
;
1919 Elf32_Internal_Shdr
*hdr
;
1922 register const char *name
;
1924 name
= bfd_get_section_name (abfd
, sec
);
1926 /* This is an ugly, but unfortunately necessary hack that is
1927 needed when producing EFI binaries on x86. It tells
1928 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1929 containing ELF relocation info. We need this hack in order to
1930 be able to generate ELF binaries that can be translated into
1931 EFI applications (which are essentially COFF objects). Those
1932 files contain a COFF ".reloc" section inside an ELFNN object,
1933 which would normally cause BFD to segfault because it would
1934 attempt to interpret this section as containing relocation
1935 entries for section "oc". With this hack enabled, ".reloc"
1936 will be treated as a normal data section, which will avoid the
1937 segfault. However, you won't be able to create an ELFNN binary
1938 with a section named "oc" that needs relocations, but that's
1939 the kind of ugly side-effects you get when detecting section
1940 types based on their names... In practice, this limitation is
1941 unlikely to bite. */
1942 if (strcmp (name
, ".reloc") == 0)
1943 hdr
->sh_type
= SHT_PROGBITS
;
1948 /* Return the base VMA address which should be subtracted from real addresses
1949 when resolving @dtpoff relocation.
1950 This is PT_TLS segment p_vaddr. */
1954 struct bfd_link_info
*info
;
1956 BFD_ASSERT (elf_hash_table (info
)->tls_segment
!= NULL
);
1957 return elf_hash_table (info
)->tls_segment
->start
;
1960 /* Return the relocation value for @tpoff relocation
1961 if STT_TLS virtual address is ADDRESS. */
1964 tpoff (info
, address
)
1965 struct bfd_link_info
*info
;
1968 struct elf_link_tls_segment
*tls_segment
1969 = elf_hash_table (info
)->tls_segment
;
1971 BFD_ASSERT (tls_segment
!= NULL
);
1972 return (align_power (tls_segment
->size
, tls_segment
->align
)
1973 + tls_segment
->start
- address
);
1976 /* Relocate an i386 ELF section. */
1979 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1980 contents
, relocs
, local_syms
, local_sections
)
1982 struct bfd_link_info
*info
;
1984 asection
*input_section
;
1986 Elf_Internal_Rela
*relocs
;
1987 Elf_Internal_Sym
*local_syms
;
1988 asection
**local_sections
;
1990 struct elf_i386_link_hash_table
*htab
;
1991 Elf_Internal_Shdr
*symtab_hdr
;
1992 struct elf_link_hash_entry
**sym_hashes
;
1993 bfd_vma
*local_got_offsets
;
1994 Elf_Internal_Rela
*rel
;
1995 Elf_Internal_Rela
*relend
;
1997 htab
= elf_i386_hash_table (info
);
1998 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1999 sym_hashes
= elf_sym_hashes (input_bfd
);
2000 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2003 relend
= relocs
+ input_section
->reloc_count
;
2004 for (; rel
< relend
; rel
++)
2006 unsigned int r_type
;
2007 reloc_howto_type
*howto
;
2008 unsigned long r_symndx
;
2009 struct elf_link_hash_entry
*h
;
2010 Elf_Internal_Sym
*sym
;
2014 boolean unresolved_reloc
;
2015 bfd_reloc_status_type r
;
2019 r_type
= ELF32_R_TYPE (rel
->r_info
);
2020 if (r_type
== (int) R_386_GNU_VTINHERIT
2021 || r_type
== (int) R_386_GNU_VTENTRY
)
2024 if ((indx
= (unsigned) r_type
) >= R_386_standard
2025 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2026 >= R_386_ext
- R_386_standard
)
2027 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2028 >= R_386_tls
- R_386_ext
))
2030 bfd_set_error (bfd_error_bad_value
);
2033 howto
= elf_howto_table
+ indx
;
2035 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2037 if (info
->relocateable
)
2042 /* This is a relocatable link. We don't have to change
2043 anything, unless the reloc is against a section symbol,
2044 in which case we have to adjust according to where the
2045 section symbol winds up in the output section. */
2046 if (r_symndx
>= symtab_hdr
->sh_info
)
2049 sym
= local_syms
+ r_symndx
;
2050 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2053 sec
= local_sections
[r_symndx
];
2054 val
= sec
->output_offset
;
2058 where
= contents
+ rel
->r_offset
;
2059 switch (howto
->size
)
2061 /* FIXME: overflow checks. */
2063 val
+= bfd_get_8 (input_bfd
, where
);
2064 bfd_put_8 (input_bfd
, val
, where
);
2067 val
+= bfd_get_16 (input_bfd
, where
);
2068 bfd_put_16 (input_bfd
, val
, where
);
2071 val
+= bfd_get_32 (input_bfd
, where
);
2072 bfd_put_32 (input_bfd
, val
, where
);
2080 /* This is a final link. */
2084 unresolved_reloc
= false;
2085 if (r_symndx
< symtab_hdr
->sh_info
)
2087 sym
= local_syms
+ r_symndx
;
2088 sec
= local_sections
[r_symndx
];
2089 relocation
= (sec
->output_section
->vma
2090 + sec
->output_offset
2092 if ((sec
->flags
& SEC_MERGE
)
2093 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2097 bfd_byte
*where
= contents
+ rel
->r_offset
;
2099 switch (howto
->size
)
2102 addend
= bfd_get_8 (input_bfd
, where
);
2103 if (howto
->pc_relative
)
2105 addend
= (addend
^ 0x80) - 0x80;
2110 addend
= bfd_get_16 (input_bfd
, where
);
2111 if (howto
->pc_relative
)
2113 addend
= (addend
^ 0x8000) - 0x8000;
2118 addend
= bfd_get_32 (input_bfd
, where
);
2119 if (howto
->pc_relative
)
2121 addend
= (addend
^ 0x80000000) - 0x80000000;
2130 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2131 addend
-= relocation
;
2132 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2134 switch (howto
->size
)
2137 /* FIXME: overflow checks. */
2138 if (howto
->pc_relative
)
2140 bfd_put_8 (input_bfd
, addend
, where
);
2143 if (howto
->pc_relative
)
2145 bfd_put_16 (input_bfd
, addend
, where
);
2148 if (howto
->pc_relative
)
2150 bfd_put_32 (input_bfd
, addend
, where
);
2157 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2158 while (h
->root
.type
== bfd_link_hash_indirect
2159 || h
->root
.type
== bfd_link_hash_warning
)
2160 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2163 if (h
->root
.type
== bfd_link_hash_defined
2164 || h
->root
.type
== bfd_link_hash_defweak
)
2166 sec
= h
->root
.u
.def
.section
;
2167 if (sec
->output_section
== NULL
)
2168 /* Set a flag that will be cleared later if we find a
2169 relocation value for this symbol. output_section
2170 is typically NULL for symbols satisfied by a shared
2172 unresolved_reloc
= true;
2174 relocation
= (h
->root
.u
.def
.value
2175 + sec
->output_section
->vma
2176 + sec
->output_offset
);
2178 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2180 else if (info
->shared
2181 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
2182 && !info
->no_undefined
2183 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2187 if (! ((*info
->callbacks
->undefined_symbol
)
2188 (info
, h
->root
.root
.string
, input_bfd
,
2189 input_section
, rel
->r_offset
,
2190 (!info
->shared
|| info
->no_undefined
2191 || ELF_ST_VISIBILITY (h
->other
)))))
2199 /* Relocation is to the entry for this symbol in the global
2201 if (htab
->sgot
== NULL
)
2208 off
= h
->got
.offset
;
2209 dyn
= htab
->elf
.dynamic_sections_created
;
2210 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
2214 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2215 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
2217 /* This is actually a static link, or it is a
2218 -Bsymbolic link and the symbol is defined
2219 locally, or the symbol was forced to be local
2220 because of a version file. We must initialize
2221 this entry in the global offset table. Since the
2222 offset must always be a multiple of 4, we use the
2223 least significant bit to record whether we have
2224 initialized it already.
2226 When doing a dynamic link, we create a .rel.got
2227 relocation entry to initialize the value. This
2228 is done in the finish_dynamic_symbol routine. */
2233 bfd_put_32 (output_bfd
, relocation
,
2234 htab
->sgot
->contents
+ off
);
2239 unresolved_reloc
= false;
2243 if (local_got_offsets
== NULL
)
2246 off
= local_got_offsets
[r_symndx
];
2248 /* The offset must always be a multiple of 4. We use
2249 the least significant bit to record whether we have
2250 already generated the necessary reloc. */
2255 bfd_put_32 (output_bfd
, relocation
,
2256 htab
->sgot
->contents
+ off
);
2261 Elf_Internal_Rel outrel
;
2262 Elf32_External_Rel
*loc
;
2264 srelgot
= htab
->srelgot
;
2265 if (srelgot
== NULL
)
2268 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2269 + htab
->sgot
->output_offset
2271 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2272 loc
= (Elf32_External_Rel
*) srelgot
->contents
;
2273 loc
+= srelgot
->reloc_count
++;
2274 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2277 local_got_offsets
[r_symndx
] |= 1;
2281 if (off
>= (bfd_vma
) -2)
2284 relocation
= htab
->sgot
->output_offset
+ off
;
2288 /* Relocation is relative to the start of the global offset
2291 /* Note that sgot->output_offset is not involved in this
2292 calculation. We always want the start of .got. If we
2293 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2294 permitted by the ABI, we might have to change this
2296 relocation
-= htab
->sgot
->output_section
->vma
;
2300 /* Use global offset table as symbol value. */
2301 relocation
= htab
->sgot
->output_section
->vma
;
2302 unresolved_reloc
= false;
2306 /* Relocation is to the entry for this symbol in the
2307 procedure linkage table. */
2309 /* Resolve a PLT32 reloc against a local symbol directly,
2310 without using the procedure linkage table. */
2314 if (h
->plt
.offset
== (bfd_vma
) -1
2315 || htab
->splt
== NULL
)
2317 /* We didn't make a PLT entry for this symbol. This
2318 happens when statically linking PIC code, or when
2319 using -Bsymbolic. */
2323 relocation
= (htab
->splt
->output_section
->vma
2324 + htab
->splt
->output_offset
2326 unresolved_reloc
= false;
2331 /* r_symndx will be zero only for relocs against symbols
2332 from removed linkonce sections, or sections discarded by
2335 || (input_section
->flags
& SEC_ALLOC
) == 0)
2339 && (r_type
!= R_386_PC32
2342 && (! info
->symbolic
2343 || (h
->elf_link_hash_flags
2344 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2348 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2349 && (((h
->elf_link_hash_flags
2350 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2351 && (h
->elf_link_hash_flags
2352 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
2353 || h
->root
.type
== bfd_link_hash_undefweak
2354 || h
->root
.type
== bfd_link_hash_undefined
)))
2356 Elf_Internal_Rel outrel
;
2357 boolean skip
, relocate
;
2359 Elf32_External_Rel
*loc
;
2361 /* When generating a shared object, these relocations
2362 are copied into the output file to be resolved at run
2369 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2371 if (outrel
.r_offset
== (bfd_vma
) -1)
2373 else if (outrel
.r_offset
== (bfd_vma
) -2)
2374 skip
= true, relocate
= true;
2375 outrel
.r_offset
+= (input_section
->output_section
->vma
2376 + input_section
->output_offset
);
2379 memset (&outrel
, 0, sizeof outrel
);
2382 && (r_type
== R_386_PC32
2385 || (h
->elf_link_hash_flags
2386 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2387 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2390 /* This symbol is local, or marked to become local. */
2392 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2395 sreloc
= elf_section_data (input_section
)->sreloc
;
2399 loc
= (Elf32_External_Rel
*) sreloc
->contents
;
2400 loc
+= sreloc
->reloc_count
++;
2401 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2403 /* If this reloc is against an external symbol, we do
2404 not want to fiddle with the addend. Otherwise, we
2405 need to include the symbol value so that it becomes
2406 an addend for the dynamic reloc. */
2413 case R_386_TLS_IE_32
:
2414 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2415 tls_type
= GOT_UNKNOWN
;
2416 if (h
== NULL
&& local_got_offsets
)
2417 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2420 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2421 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2422 r_type
= R_386_TLS_LE_32
;
2424 if (r_type
== R_386_TLS_GD
&& tls_type
== GOT_TLS_IE
)
2425 r_type
= R_386_TLS_IE_32
;
2427 if (r_type
== R_386_TLS_LE_32
)
2429 BFD_ASSERT (! unresolved_reloc
);
2430 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2432 unsigned int val
, type
;
2435 /* GD->LE transition. */
2436 BFD_ASSERT (rel
->r_offset
>= 2);
2437 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2438 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2439 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2440 BFD_ASSERT (bfd_get_8 (input_bfd
,
2441 contents
+ rel
->r_offset
+ 4)
2443 BFD_ASSERT (rel
+ 1 < relend
);
2444 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2445 roff
= rel
->r_offset
+ 5;
2446 val
= bfd_get_8 (input_bfd
,
2447 contents
+ rel
->r_offset
- 1);
2450 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2452 movl %gs:0, %eax; subl $foo@tpoff, %eax
2453 (6 byte form of subl). */
2454 BFD_ASSERT (rel
->r_offset
>= 3);
2455 BFD_ASSERT (bfd_get_8 (input_bfd
,
2456 contents
+ rel
->r_offset
- 3)
2458 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2459 memcpy (contents
+ rel
->r_offset
- 3,
2460 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2464 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2465 if (rel
->r_offset
+ 10 <= input_section
->_raw_size
2466 && bfd_get_8 (input_bfd
,
2467 contents
+ rel
->r_offset
+ 9) == 0x90)
2469 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2471 movl %gs:0, %eax; subl $foo@tpoff, %eax
2472 (6 byte form of subl). */
2473 memcpy (contents
+ rel
->r_offset
- 2,
2474 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2475 roff
= rel
->r_offset
+ 6;
2479 /* leal foo(%reg), %eax; call ___tls_get_addr
2481 movl %gs:0, %eax; subl $foo@tpoff, %eax
2482 (5 byte form of subl). */
2483 memcpy (contents
+ rel
->r_offset
- 2,
2484 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2487 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2489 /* Skip R_386_PLT32. */
2495 unsigned int val
, type
;
2497 /* IE->LE transition:
2498 Originally it can be either:
2499 subl foo(%reg1), %reg2
2501 movl foo(%reg1), %reg2
2505 movl $foo, %reg2 (6 byte form) */
2506 BFD_ASSERT (rel
->r_offset
>= 2);
2507 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2508 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2509 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->_raw_size
);
2513 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2514 bfd_put_8 (output_bfd
, 0xc7,
2515 contents
+ rel
->r_offset
- 2);
2516 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2517 contents
+ rel
->r_offset
- 1);
2519 else if (type
== 0x2b)
2522 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2523 bfd_put_8 (output_bfd
, 0x81,
2524 contents
+ rel
->r_offset
- 2);
2525 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2526 contents
+ rel
->r_offset
- 1);
2530 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2531 contents
+ rel
->r_offset
);
2536 if (htab
->sgot
== NULL
)
2540 off
= h
->got
.offset
;
2543 if (local_got_offsets
== NULL
)
2546 off
= local_got_offsets
[r_symndx
];
2553 Elf_Internal_Rel outrel
;
2554 Elf32_External_Rel
*loc
;
2557 if (htab
->srelgot
== NULL
)
2560 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2561 + htab
->sgot
->output_offset
+ off
);
2563 bfd_put_32 (output_bfd
, 0,
2564 htab
->sgot
->contents
+ off
);
2565 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2566 if (r_type
== R_386_TLS_GD
)
2567 dr_type
= R_386_TLS_DTPMOD32
;
2569 dr_type
= R_386_TLS_TPOFF32
;
2570 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
2571 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2572 loc
+= htab
->srelgot
->reloc_count
++;
2573 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2575 if (r_type
== R_386_TLS_GD
)
2579 BFD_ASSERT (! unresolved_reloc
);
2580 bfd_put_32 (output_bfd
,
2581 relocation
- dtpoff_base (info
),
2582 htab
->sgot
->contents
+ off
+ 4);
2586 bfd_put_32 (output_bfd
, 0,
2587 htab
->sgot
->contents
+ off
+ 4);
2588 outrel
.r_info
= ELF32_R_INFO (indx
,
2589 R_386_TLS_DTPOFF32
);
2590 outrel
.r_offset
+= 4;
2591 htab
->srelgot
->reloc_count
++;
2593 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
2601 local_got_offsets
[r_symndx
] |= 1;
2604 if (off
>= (bfd_vma
) -2)
2606 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
2608 relocation
= htab
->sgot
->output_offset
+ off
;
2609 unresolved_reloc
= false;
2613 unsigned int val
, type
;
2616 /* GD->IE transition. */
2617 BFD_ASSERT (rel
->r_offset
>= 2);
2618 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2619 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2620 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2621 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2623 BFD_ASSERT (rel
+ 1 < relend
);
2624 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2625 roff
= rel
->r_offset
- 3;
2626 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2629 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2631 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2632 BFD_ASSERT (rel
->r_offset
>= 3);
2633 BFD_ASSERT (bfd_get_8 (input_bfd
,
2634 contents
+ rel
->r_offset
- 3)
2636 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2641 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2643 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2644 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->_raw_size
);
2645 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2646 BFD_ASSERT (bfd_get_8 (input_bfd
,
2647 contents
+ rel
->r_offset
+ 9)
2649 roff
= rel
->r_offset
- 2;
2651 memcpy (contents
+ roff
,
2652 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2653 contents
[roff
+ 7] = 0x80 | (val
& 7);
2654 bfd_put_32 (output_bfd
, htab
->sgot
->output_offset
+ off
,
2655 contents
+ roff
+ 8);
2656 /* Skip R_386_PLT32. */
2667 /* LD->LE transition:
2669 leal foo(%reg), %eax; call ___tls_get_addr.
2671 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2672 BFD_ASSERT (rel
->r_offset
>= 2);
2673 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
2675 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2676 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2677 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2678 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2680 BFD_ASSERT (rel
+ 1 < relend
);
2681 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2682 memcpy (contents
+ rel
->r_offset
- 2,
2683 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2684 /* Skip R_386_PLT32. */
2689 if (htab
->sgot
== NULL
)
2692 off
= htab
->tls_ldm_got
.offset
;
2697 Elf_Internal_Rel outrel
;
2698 Elf32_External_Rel
*loc
;
2700 if (htab
->srelgot
== NULL
)
2703 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2704 + htab
->sgot
->output_offset
+ off
);
2706 bfd_put_32 (output_bfd
, 0,
2707 htab
->sgot
->contents
+ off
);
2708 bfd_put_32 (output_bfd
, 0,
2709 htab
->sgot
->contents
+ off
+ 4);
2710 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
2711 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2712 loc
+= htab
->srelgot
->reloc_count
++;
2713 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2714 htab
->tls_ldm_got
.offset
|= 1;
2716 relocation
= htab
->sgot
->output_offset
+ off
;
2717 unresolved_reloc
= false;
2720 case R_386_TLS_LDO_32
:
2722 relocation
-= dtpoff_base (info
);
2724 /* When converting LDO to LE, we must negate. */
2725 relocation
= -tpoff (info
, relocation
);
2728 case R_386_TLS_LE_32
:
2729 relocation
= tpoff (info
, relocation
);
2733 relocation
= -tpoff (info
, relocation
);
2740 /* FIXME: Why do we allow debugging sections to escape this error?
2741 More importantly, why do we not emit dynamic relocs for
2742 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2743 If we had emitted the dynamic reloc, we could remove the
2745 if (unresolved_reloc
2747 && (input_section
->flags
& SEC_DEBUGGING
) != 0
2748 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2749 (*_bfd_error_handler
)
2750 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2751 bfd_archive_filename (input_bfd
),
2752 bfd_get_section_name (input_bfd
, input_section
),
2753 (long) rel
->r_offset
,
2754 h
->root
.root
.string
);
2756 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2757 contents
, rel
->r_offset
,
2758 relocation
, (bfd_vma
) 0);
2760 if (r
!= bfd_reloc_ok
)
2765 name
= h
->root
.root
.string
;
2768 name
= bfd_elf_string_from_elf_section (input_bfd
,
2769 symtab_hdr
->sh_link
,
2774 name
= bfd_section_name (input_bfd
, sec
);
2777 if (r
== bfd_reloc_overflow
)
2779 if (! ((*info
->callbacks
->reloc_overflow
)
2780 (info
, name
, howto
->name
, (bfd_vma
) 0,
2781 input_bfd
, input_section
, rel
->r_offset
)))
2786 (*_bfd_error_handler
)
2787 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2788 bfd_archive_filename (input_bfd
),
2789 bfd_get_section_name (input_bfd
, input_section
),
2790 (long) rel
->r_offset
, name
, (int) r
);
2799 /* Finish up dynamic symbol handling. We set the contents of various
2800 dynamic sections here. */
2803 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2805 struct bfd_link_info
*info
;
2806 struct elf_link_hash_entry
*h
;
2807 Elf_Internal_Sym
*sym
;
2809 struct elf_i386_link_hash_table
*htab
;
2811 htab
= elf_i386_hash_table (info
);
2813 if (h
->plt
.offset
!= (bfd_vma
) -1)
2817 Elf_Internal_Rel rel
;
2818 Elf32_External_Rel
*loc
;
2820 /* This symbol has an entry in the procedure linkage table. Set
2823 if (h
->dynindx
== -1
2824 || htab
->splt
== NULL
2825 || htab
->sgotplt
== NULL
2826 || htab
->srelplt
== NULL
)
2829 /* Get the index in the procedure linkage table which
2830 corresponds to this symbol. This is the index of this symbol
2831 in all the symbols for which we are making plt entries. The
2832 first entry in the procedure linkage table is reserved. */
2833 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2835 /* Get the offset into the .got table of the entry that
2836 corresponds to this function. Each .got entry is 4 bytes.
2837 The first three are reserved. */
2838 got_offset
= (plt_index
+ 3) * 4;
2840 /* Fill in the entry in the procedure linkage table. */
2843 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2845 bfd_put_32 (output_bfd
,
2846 (htab
->sgotplt
->output_section
->vma
2847 + htab
->sgotplt
->output_offset
2849 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2853 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2855 bfd_put_32 (output_bfd
, got_offset
,
2856 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2859 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2860 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2861 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2862 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2864 /* Fill in the entry in the global offset table. */
2865 bfd_put_32 (output_bfd
,
2866 (htab
->splt
->output_section
->vma
2867 + htab
->splt
->output_offset
2870 htab
->sgotplt
->contents
+ got_offset
);
2872 /* Fill in the entry in the .rel.plt section. */
2873 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2874 + htab
->sgotplt
->output_offset
2876 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2877 loc
= (Elf32_External_Rel
*) htab
->srelplt
->contents
+ plt_index
;
2878 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2880 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2882 /* Mark the symbol as undefined, rather than as defined in
2883 the .plt section. Leave the value alone. This is a clue
2884 for the dynamic linker, to make function pointer
2885 comparisons work between an application and shared
2887 sym
->st_shndx
= SHN_UNDEF
;
2891 if (h
->got
.offset
!= (bfd_vma
) -1
2892 && elf_i386_hash_entry(h
)->tls_type
!= GOT_TLS_GD
2893 && elf_i386_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
2895 Elf_Internal_Rel rel
;
2896 Elf32_External_Rel
*loc
;
2898 /* This symbol has an entry in the global offset table. Set it
2901 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2904 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2905 + htab
->sgot
->output_offset
2906 + (h
->got
.offset
& ~(bfd_vma
) 1));
2908 /* If this is a static link, or it is a -Bsymbolic link and the
2909 symbol is defined locally or was forced to be local because
2910 of a version file, we just want to emit a RELATIVE reloc.
2911 The entry in the global offset table will already have been
2912 initialized in the relocate_section function. */
2916 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2917 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2919 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2920 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2924 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2925 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2926 htab
->sgot
->contents
+ h
->got
.offset
);
2927 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2930 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2931 loc
+= htab
->srelgot
->reloc_count
++;
2932 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2935 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2937 Elf_Internal_Rel rel
;
2938 Elf32_External_Rel
*loc
;
2940 /* This symbol needs a copy reloc. Set it up. */
2942 if (h
->dynindx
== -1
2943 || (h
->root
.type
!= bfd_link_hash_defined
2944 && h
->root
.type
!= bfd_link_hash_defweak
)
2945 || htab
->srelbss
== NULL
)
2948 rel
.r_offset
= (h
->root
.u
.def
.value
2949 + h
->root
.u
.def
.section
->output_section
->vma
2950 + h
->root
.u
.def
.section
->output_offset
);
2951 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2952 loc
= (Elf32_External_Rel
*) htab
->srelbss
->contents
;
2953 loc
+= htab
->srelbss
->reloc_count
++;
2954 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2957 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2958 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2959 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2960 sym
->st_shndx
= SHN_ABS
;
2965 /* Used to decide how to sort relocs in an optimal manner for the
2966 dynamic linker, before writing them out. */
2968 static enum elf_reloc_type_class
2969 elf_i386_reloc_type_class (rela
)
2970 const Elf_Internal_Rela
*rela
;
2972 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2974 case R_386_RELATIVE
:
2975 return reloc_class_relative
;
2976 case R_386_JUMP_SLOT
:
2977 return reloc_class_plt
;
2979 return reloc_class_copy
;
2981 return reloc_class_normal
;
2985 /* Finish up the dynamic sections. */
2988 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2990 struct bfd_link_info
*info
;
2992 struct elf_i386_link_hash_table
*htab
;
2996 htab
= elf_i386_hash_table (info
);
2997 dynobj
= htab
->elf
.dynobj
;
2998 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3000 if (htab
->elf
.dynamic_sections_created
)
3002 Elf32_External_Dyn
*dyncon
, *dynconend
;
3004 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3007 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3008 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3009 for (; dyncon
< dynconend
; dyncon
++)
3011 Elf_Internal_Dyn dyn
;
3014 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3022 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
3026 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
3030 s
= htab
->srelplt
->output_section
;
3031 if (s
->_cooked_size
!= 0)
3032 dyn
.d_un
.d_val
= s
->_cooked_size
;
3034 dyn
.d_un
.d_val
= s
->_raw_size
;
3038 /* My reading of the SVR4 ABI indicates that the
3039 procedure linkage table relocs (DT_JMPREL) should be
3040 included in the overall relocs (DT_REL). This is
3041 what Solaris does. However, UnixWare can not handle
3042 that case. Therefore, we override the DT_RELSZ entry
3043 here to make it not include the JMPREL relocs. Since
3044 the linker script arranges for .rel.plt to follow all
3045 other relocation sections, we don't have to worry
3046 about changing the DT_REL entry. */
3047 if (htab
->srelplt
!= NULL
)
3049 s
= htab
->srelplt
->output_section
;
3050 if (s
->_cooked_size
!= 0)
3051 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3053 dyn
.d_un
.d_val
-= s
->_raw_size
;
3058 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3061 /* Fill in the first entry in the procedure linkage table. */
3062 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
3065 memcpy (htab
->splt
->contents
,
3066 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
3069 memcpy (htab
->splt
->contents
,
3070 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
3071 bfd_put_32 (output_bfd
,
3072 (htab
->sgotplt
->output_section
->vma
3073 + htab
->sgotplt
->output_offset
3075 htab
->splt
->contents
+ 2);
3076 bfd_put_32 (output_bfd
,
3077 (htab
->sgotplt
->output_section
->vma
3078 + htab
->sgotplt
->output_offset
3080 htab
->splt
->contents
+ 8);
3083 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3084 really seem like the right value. */
3085 elf_section_data (htab
->splt
->output_section
)
3086 ->this_hdr
.sh_entsize
= 4;
3092 /* Fill in the first three entries in the global offset table. */
3093 if (htab
->sgotplt
->_raw_size
> 0)
3095 bfd_put_32 (output_bfd
,
3096 (sdyn
== NULL
? (bfd_vma
) 0
3097 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3098 htab
->sgotplt
->contents
);
3099 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
3100 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
3103 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3108 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3109 #define TARGET_LITTLE_NAME "elf32-i386"
3110 #define ELF_ARCH bfd_arch_i386
3111 #define ELF_MACHINE_CODE EM_386
3112 #define ELF_MAXPAGESIZE 0x1000
3114 #define elf_backend_can_gc_sections 1
3115 #define elf_backend_can_refcount 1
3116 #define elf_backend_want_got_plt 1
3117 #define elf_backend_plt_readonly 1
3118 #define elf_backend_want_plt_sym 0
3119 #define elf_backend_got_header_size 12
3120 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3122 #define elf_info_to_howto elf_i386_info_to_howto
3123 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3125 #define bfd_elf32_mkobject elf_i386_mkobject
3126 #define elf_backend_object_p elf_i386_object_p
3128 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3129 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3130 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3132 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3133 #define elf_backend_check_relocs elf_i386_check_relocs
3134 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3135 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3136 #define elf_backend_fake_sections elf_i386_fake_sections
3137 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3138 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3139 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3140 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3141 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3142 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3143 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3144 #define elf_backend_relocate_section elf_i386_relocate_section
3145 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3147 #ifndef ELF32_I386_C_INCLUDED
3148 #include "elf32-target.h"