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
->tls_ldm_got
.refcount
= 0;
701 ret
->sym_sec
.abfd
= NULL
;
703 return &ret
->elf
.root
;
706 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
707 shortcuts to them in our hash table. */
710 create_got_section (dynobj
, info
)
712 struct bfd_link_info
*info
;
714 struct elf_i386_link_hash_table
*htab
;
716 if (! _bfd_elf_create_got_section (dynobj
, info
))
719 htab
= elf_i386_hash_table (info
);
720 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
721 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
722 if (!htab
->sgot
|| !htab
->sgotplt
)
725 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
726 if (htab
->srelgot
== NULL
727 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
728 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
729 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
731 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
736 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
737 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
741 elf_i386_create_dynamic_sections (dynobj
, info
)
743 struct bfd_link_info
*info
;
745 struct elf_i386_link_hash_table
*htab
;
747 htab
= elf_i386_hash_table (info
);
748 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
751 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
754 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
755 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
756 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
758 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
760 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
761 || (!info
->shared
&& !htab
->srelbss
))
767 /* Copy the extra info we tack onto an elf_link_hash_entry. */
770 elf_i386_copy_indirect_symbol (dir
, ind
)
771 struct elf_link_hash_entry
*dir
, *ind
;
773 struct elf_i386_link_hash_entry
*edir
, *eind
;
775 edir
= (struct elf_i386_link_hash_entry
*) dir
;
776 eind
= (struct elf_i386_link_hash_entry
*) ind
;
778 if (eind
->dyn_relocs
!= NULL
)
780 if (edir
->dyn_relocs
!= NULL
)
782 struct elf_i386_dyn_relocs
**pp
;
783 struct elf_i386_dyn_relocs
*p
;
785 if (ind
->root
.type
== bfd_link_hash_indirect
)
788 /* Add reloc counts against the weak sym to the strong sym
789 list. Merge any entries against the same section. */
790 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
792 struct elf_i386_dyn_relocs
*q
;
794 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
795 if (q
->sec
== p
->sec
)
797 q
->pc_count
+= p
->pc_count
;
798 q
->count
+= p
->count
;
805 *pp
= edir
->dyn_relocs
;
808 edir
->dyn_relocs
= eind
->dyn_relocs
;
809 eind
->dyn_relocs
= NULL
;
812 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
816 elf_i386_tls_transition (info
, r_type
, is_local
)
817 struct bfd_link_info
*info
;
827 case R_386_TLS_IE_32
:
829 return R_386_TLS_LE_32
;
830 return R_386_TLS_IE_32
;
832 return R_386_TLS_LE_32
;
838 /* Look through the relocs for a section during the first phase, and
839 calculate needed space in the global offset table, procedure linkage
840 table, and dynamic reloc sections. */
843 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
845 struct bfd_link_info
*info
;
847 const Elf_Internal_Rela
*relocs
;
849 struct elf_i386_link_hash_table
*htab
;
850 Elf_Internal_Shdr
*symtab_hdr
;
851 struct elf_link_hash_entry
**sym_hashes
;
852 const Elf_Internal_Rela
*rel
;
853 const Elf_Internal_Rela
*rel_end
;
856 if (info
->relocateable
)
859 htab
= elf_i386_hash_table (info
);
860 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
861 sym_hashes
= elf_sym_hashes (abfd
);
865 rel_end
= relocs
+ sec
->reloc_count
;
866 for (rel
= relocs
; rel
< rel_end
; rel
++)
869 unsigned long r_symndx
;
870 struct elf_link_hash_entry
*h
;
872 r_symndx
= ELF32_R_SYM (rel
->r_info
);
873 r_type
= ELF32_R_TYPE (rel
->r_info
);
875 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
877 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
878 bfd_archive_filename (abfd
),
883 if (r_symndx
< symtab_hdr
->sh_info
)
886 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
888 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
892 case R_386_TLS_IE_32
:
894 info
->flags
|= DF_STATIC_TLS
;
898 /* This symbol requires a global offset table entry. */
900 int tls_type
, old_tls_type
;
905 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
906 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
907 case R_386_TLS_IE_32
: tls_type
= GOT_TLS_IE
; break;
912 h
->got
.refcount
+= 1;
913 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
917 bfd_signed_vma
*local_got_refcounts
;
919 /* This is a global offset table entry for a local symbol. */
920 local_got_refcounts
= elf_local_got_refcounts (abfd
);
921 if (local_got_refcounts
== NULL
)
925 size
= symtab_hdr
->sh_info
;
926 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
927 local_got_refcounts
= ((bfd_signed_vma
*)
928 bfd_zalloc (abfd
, size
));
929 if (local_got_refcounts
== NULL
)
931 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
932 elf_i386_local_got_tls_type (abfd
)
933 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
935 local_got_refcounts
[r_symndx
] += 1;
936 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
939 /* If a TLS symbol is accessed using IE at least once,
940 there is no point to use dynamic model for it. */
941 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
942 && (old_tls_type
!= GOT_TLS_GD
|| tls_type
!= GOT_TLS_IE
))
944 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
945 tls_type
= GOT_TLS_IE
;
948 (*_bfd_error_handler
)
949 (_("%s: `%s' accessed both as normal and thread local symbol"),
950 bfd_archive_filename (abfd
), h
->root
.root
.string
);
955 if (old_tls_type
!= tls_type
)
958 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
960 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
968 if (htab
->sgot
== NULL
)
970 if (htab
->elf
.dynobj
== NULL
)
971 htab
->elf
.dynobj
= abfd
;
972 if (!create_got_section (htab
->elf
.dynobj
, info
))
978 htab
->tls_ldm_got
.refcount
+= 1;
982 /* This symbol requires a procedure linkage table entry. We
983 actually build the entry in adjust_dynamic_symbol,
984 because this might be a case of linking PIC code which is
985 never referenced by a dynamic object, in which case we
986 don't need to generate a procedure linkage table entry
989 /* If this is a local symbol, we resolve it directly without
990 creating a procedure linkage table entry. */
994 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
995 h
->plt
.refcount
+= 1;
1000 if (h
!= NULL
&& !info
->shared
)
1002 /* If this reloc is in a read-only section, we might
1003 need a copy reloc. We can't check reliably at this
1004 stage whether the section is read-only, as input
1005 sections have not yet been mapped to output sections.
1006 Tentatively set the flag for now, and correct in
1007 adjust_dynamic_symbol. */
1008 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1010 /* We may need a .plt entry if the function this reloc
1011 refers to is in a shared lib. */
1012 h
->plt
.refcount
+= 1;
1015 /* If we are creating a shared library, and this is a reloc
1016 against a global symbol, or a non PC relative reloc
1017 against a local symbol, then we need to copy the reloc
1018 into the shared library. However, if we are linking with
1019 -Bsymbolic, we do not need to copy a reloc against a
1020 global symbol which is defined in an object we are
1021 including in the link (i.e., DEF_REGULAR is set). At
1022 this point we have not seen all the input files, so it is
1023 possible that DEF_REGULAR is not set now but will be set
1024 later (it is never cleared). In case of a weak definition,
1025 DEF_REGULAR may be cleared later by a strong definition in
1026 a shared library. We account for that possibility below by
1027 storing information in the relocs_copied field of the hash
1028 table entry. A similar situation occurs when creating
1029 shared libraries and symbol visibility changes render the
1032 If on the other hand, we are creating an executable, we
1033 may need to keep relocations for symbols satisfied by a
1034 dynamic library if we manage to avoid copy relocs for the
1037 && (sec
->flags
& SEC_ALLOC
) != 0
1038 && (r_type
!= R_386_PC32
1040 && (! info
->symbolic
1041 || h
->root
.type
== bfd_link_hash_defweak
1042 || (h
->elf_link_hash_flags
1043 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1045 && (sec
->flags
& SEC_ALLOC
) != 0
1047 && (h
->root
.type
== bfd_link_hash_defweak
1048 || (h
->elf_link_hash_flags
1049 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1051 struct elf_i386_dyn_relocs
*p
;
1052 struct elf_i386_dyn_relocs
**head
;
1054 /* We must copy these reloc types into the output file.
1055 Create a reloc section in dynobj and make room for
1061 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1062 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1064 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1068 if (strncmp (name
, ".rel", 4) != 0
1069 || strcmp (bfd_get_section_name (abfd
, sec
),
1072 (*_bfd_error_handler
)
1073 (_("%s: bad relocation section name `%s\'"),
1074 bfd_archive_filename (abfd
), name
);
1077 if (htab
->elf
.dynobj
== NULL
)
1078 htab
->elf
.dynobj
= abfd
;
1080 dynobj
= htab
->elf
.dynobj
;
1081 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1086 sreloc
= bfd_make_section (dynobj
, name
);
1087 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1088 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1089 if ((sec
->flags
& SEC_ALLOC
) != 0)
1090 flags
|= SEC_ALLOC
| SEC_LOAD
;
1092 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1093 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1096 elf_section_data (sec
)->sreloc
= sreloc
;
1099 /* If this is a global symbol, we count the number of
1100 relocations we need for this symbol. */
1103 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1107 /* Track dynamic relocs needed for local syms too.
1108 We really need local syms available to do this
1112 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1117 head
= ((struct elf_i386_dyn_relocs
**)
1118 &elf_section_data (s
)->local_dynrel
);
1122 if (p
== NULL
|| p
->sec
!= sec
)
1124 bfd_size_type amt
= sizeof *p
;
1125 p
= ((struct elf_i386_dyn_relocs
*)
1126 bfd_alloc (htab
->elf
.dynobj
, amt
));
1137 if (r_type
== R_386_PC32
)
1142 /* This relocation describes the C++ object vtable hierarchy.
1143 Reconstruct it for later use during GC. */
1144 case R_386_GNU_VTINHERIT
:
1145 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1149 /* This relocation describes which C++ vtable entries are actually
1150 used. Record for later use during GC. */
1151 case R_386_GNU_VTENTRY
:
1152 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1156 case R_386_TLS_LE_32
:
1160 (*_bfd_error_handler
) (_("%s: TLS local exec code cannot be linked into shared objects"),
1161 bfd_archive_filename (abfd
));
1174 /* Return the section that should be marked against GC for a given
1178 elf_i386_gc_mark_hook (sec
, info
, rel
, h
, sym
)
1180 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1181 Elf_Internal_Rela
*rel
;
1182 struct elf_link_hash_entry
*h
;
1183 Elf_Internal_Sym
*sym
;
1187 switch (ELF32_R_TYPE (rel
->r_info
))
1189 case R_386_GNU_VTINHERIT
:
1190 case R_386_GNU_VTENTRY
:
1194 switch (h
->root
.type
)
1196 case bfd_link_hash_defined
:
1197 case bfd_link_hash_defweak
:
1198 return h
->root
.u
.def
.section
;
1200 case bfd_link_hash_common
:
1201 return h
->root
.u
.c
.p
->section
;
1209 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1214 /* Update the got entry reference counts for the section being removed. */
1217 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1219 struct bfd_link_info
*info
;
1221 const Elf_Internal_Rela
*relocs
;
1223 Elf_Internal_Shdr
*symtab_hdr
;
1224 struct elf_link_hash_entry
**sym_hashes
;
1225 bfd_signed_vma
*local_got_refcounts
;
1226 const Elf_Internal_Rela
*rel
, *relend
;
1227 unsigned long r_symndx
;
1228 struct elf_link_hash_entry
*h
;
1230 elf_section_data (sec
)->local_dynrel
= NULL
;
1232 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1233 sym_hashes
= elf_sym_hashes (abfd
);
1234 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1236 relend
= relocs
+ sec
->reloc_count
;
1237 for (rel
= relocs
; rel
< relend
; rel
++)
1238 switch (elf_i386_tls_transition (info
, ELF32_R_TYPE (rel
->r_info
),
1239 ELF32_R_SYM (rel
->r_info
)
1240 >= symtab_hdr
->sh_info
))
1243 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1244 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1248 case R_386_TLS_IE_32
:
1250 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1251 if (r_symndx
>= symtab_hdr
->sh_info
)
1253 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1254 if (h
->got
.refcount
> 0)
1255 h
->got
.refcount
-= 1;
1257 else if (local_got_refcounts
!= NULL
)
1259 if (local_got_refcounts
[r_symndx
] > 0)
1260 local_got_refcounts
[r_symndx
] -= 1;
1266 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1267 if (r_symndx
>= symtab_hdr
->sh_info
)
1269 struct elf_i386_link_hash_entry
*eh
;
1270 struct elf_i386_dyn_relocs
**pp
;
1271 struct elf_i386_dyn_relocs
*p
;
1273 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1275 if (!info
->shared
&& h
->plt
.refcount
> 0)
1276 h
->plt
.refcount
-= 1;
1278 eh
= (struct elf_i386_link_hash_entry
*) h
;
1280 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1283 if (ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
1294 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1295 if (r_symndx
>= symtab_hdr
->sh_info
)
1297 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1298 if (h
->plt
.refcount
> 0)
1299 h
->plt
.refcount
-= 1;
1310 /* Adjust a symbol defined by a dynamic object and referenced by a
1311 regular object. The current definition is in some section of the
1312 dynamic object, but we're not including those sections. We have to
1313 change the definition to something the rest of the link can
1317 elf_i386_adjust_dynamic_symbol (info
, h
)
1318 struct bfd_link_info
*info
;
1319 struct elf_link_hash_entry
*h
;
1321 struct elf_i386_link_hash_table
*htab
;
1322 struct elf_i386_link_hash_entry
* eh
;
1323 struct elf_i386_dyn_relocs
*p
;
1325 unsigned int power_of_two
;
1327 /* If this is a function, put it in the procedure linkage table. We
1328 will fill in the contents of the procedure linkage table later,
1329 when we know the address of the .got section. */
1330 if (h
->type
== STT_FUNC
1331 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1333 if (h
->plt
.refcount
<= 0
1335 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1336 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1337 && h
->root
.type
!= bfd_link_hash_undefweak
1338 && h
->root
.type
!= bfd_link_hash_undefined
))
1340 /* This case can occur if we saw a PLT32 reloc in an input
1341 file, but the symbol was never referred to by a dynamic
1342 object, or if all references were garbage collected. In
1343 such a case, we don't actually need to build a procedure
1344 linkage table, and we can just do a PC32 reloc instead. */
1345 h
->plt
.offset
= (bfd_vma
) -1;
1346 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1352 /* It's possible that we incorrectly decided a .plt reloc was
1353 needed for an R_386_PC32 reloc to a non-function sym in
1354 check_relocs. We can't decide accurately between function and
1355 non-function syms in check-relocs; Objects loaded later in
1356 the link may change h->type. So fix it now. */
1357 h
->plt
.offset
= (bfd_vma
) -1;
1359 /* If this is a weak symbol, and there is a real definition, the
1360 processor independent code will have arranged for us to see the
1361 real definition first, and we can just use the same value. */
1362 if (h
->weakdef
!= NULL
)
1364 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1365 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1366 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1367 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1371 /* This is a reference to a symbol defined by a dynamic object which
1372 is not a function. */
1374 /* If we are creating a shared library, we must presume that the
1375 only references to the symbol are via the global offset table.
1376 For such cases we need not do anything here; the relocations will
1377 be handled correctly by relocate_section. */
1381 /* If there are no references to this symbol that do not use the
1382 GOT, we don't need to generate a copy reloc. */
1383 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1386 /* If -z nocopyreloc was given, we won't generate them either. */
1387 if (info
->nocopyreloc
)
1389 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1393 eh
= (struct elf_i386_link_hash_entry
*) h
;
1394 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1396 s
= p
->sec
->output_section
;
1397 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1401 /* If we didn't find any dynamic relocs in read-only sections, then
1402 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1405 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1409 /* We must allocate the symbol in our .dynbss section, which will
1410 become part of the .bss section of the executable. There will be
1411 an entry for this symbol in the .dynsym section. The dynamic
1412 object will contain position independent code, so all references
1413 from the dynamic object to this symbol will go through the global
1414 offset table. The dynamic linker will use the .dynsym entry to
1415 determine the address it must put in the global offset table, so
1416 both the dynamic object and the regular object will refer to the
1417 same memory location for the variable. */
1419 htab
= elf_i386_hash_table (info
);
1421 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1422 copy the initial value out of the dynamic object and into the
1423 runtime process image. */
1424 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1426 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rel
);
1427 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1430 /* We need to figure out the alignment required for this symbol. I
1431 have no idea how ELF linkers handle this. */
1432 power_of_two
= bfd_log2 (h
->size
);
1433 if (power_of_two
> 3)
1436 /* Apply the required alignment. */
1438 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1439 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1441 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1445 /* Define the symbol as being at this point in the section. */
1446 h
->root
.u
.def
.section
= s
;
1447 h
->root
.u
.def
.value
= s
->_raw_size
;
1449 /* Increment the section size to make room for the symbol. */
1450 s
->_raw_size
+= h
->size
;
1455 /* This is the condition under which elf_i386_finish_dynamic_symbol
1456 will be called from elflink.h. If elflink.h doesn't call our
1457 finish_dynamic_symbol routine, we'll need to do something about
1458 initializing any .plt and .got entries in elf_i386_relocate_section. */
1459 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1461 && ((INFO)->shared \
1462 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1463 && ((H)->dynindx != -1 \
1464 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1466 /* Allocate space in .plt, .got and associated reloc sections for
1470 allocate_dynrelocs (h
, inf
)
1471 struct elf_link_hash_entry
*h
;
1474 struct bfd_link_info
*info
;
1475 struct elf_i386_link_hash_table
*htab
;
1476 struct elf_i386_link_hash_entry
*eh
;
1477 struct elf_i386_dyn_relocs
*p
;
1479 if (h
->root
.type
== bfd_link_hash_indirect
)
1482 if (h
->root
.type
== bfd_link_hash_warning
)
1483 /* When warning symbols are created, they **replace** the "real"
1484 entry in the hash table, thus we never get to see the real
1485 symbol in a hash traversal. So look at it now. */
1486 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1488 info
= (struct bfd_link_info
*) inf
;
1489 htab
= elf_i386_hash_table (info
);
1491 if (htab
->elf
.dynamic_sections_created
1492 && h
->plt
.refcount
> 0)
1494 /* Make sure this symbol is output as a dynamic symbol.
1495 Undefined weak syms won't yet be marked as dynamic. */
1496 if (h
->dynindx
== -1
1497 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1499 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1503 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1505 asection
*s
= htab
->splt
;
1507 /* If this is the first .plt entry, make room for the special
1509 if (s
->_raw_size
== 0)
1510 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1512 h
->plt
.offset
= s
->_raw_size
;
1514 /* If this symbol is not defined in a regular file, and we are
1515 not generating a shared library, then set the symbol to this
1516 location in the .plt. This is required to make function
1517 pointers compare as equal between the normal executable and
1518 the shared library. */
1520 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1522 h
->root
.u
.def
.section
= s
;
1523 h
->root
.u
.def
.value
= h
->plt
.offset
;
1526 /* Make room for this entry. */
1527 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1529 /* We also need to make an entry in the .got.plt section, which
1530 will be placed in the .got section by the linker script. */
1531 htab
->sgotplt
->_raw_size
+= 4;
1533 /* We also need to make an entry in the .rel.plt section. */
1534 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
1538 h
->plt
.offset
= (bfd_vma
) -1;
1539 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1544 h
->plt
.offset
= (bfd_vma
) -1;
1545 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1548 /* If R_386_TLS_IE_32 symbol is now local to the binary,
1549 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1550 if (h
->got
.refcount
> 0
1553 && elf_i386_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1554 h
->got
.offset
= (bfd_vma
) -1;
1555 else if (h
->got
.refcount
> 0)
1559 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1561 /* Make sure this symbol is output as a dynamic symbol.
1562 Undefined weak syms won't yet be marked as dynamic. */
1563 if (h
->dynindx
== -1
1564 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1566 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1571 h
->got
.offset
= s
->_raw_size
;
1573 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1574 if (tls_type
== GOT_TLS_GD
)
1576 dyn
= htab
->elf
.dynamic_sections_created
;
1577 /* R_386_TLS_IE_32 needs one dynamic relocation,
1578 R_386_TLS_GD needs one if local symbol and two if global. */
1579 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1580 || tls_type
== GOT_TLS_IE
)
1581 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1582 else if (tls_type
== GOT_TLS_GD
)
1583 htab
->srelgot
->_raw_size
+= 2 * sizeof (Elf32_External_Rel
);
1584 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1585 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1588 h
->got
.offset
= (bfd_vma
) -1;
1590 eh
= (struct elf_i386_link_hash_entry
*) h
;
1591 if (eh
->dyn_relocs
== NULL
)
1594 /* In the shared -Bsymbolic case, discard space allocated for
1595 dynamic pc-relative relocs against symbols which turn out to be
1596 defined in regular objects. For the normal shared case, discard
1597 space for pc-relative relocs that have become local due to symbol
1598 visibility changes. */
1602 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1603 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1606 struct elf_i386_dyn_relocs
**pp
;
1608 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1610 p
->count
-= p
->pc_count
;
1621 /* For the non-shared case, discard space for relocs against
1622 symbols which turn out to need copy relocs or are not
1625 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1626 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1627 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1628 || (htab
->elf
.dynamic_sections_created
1629 && (h
->root
.type
== bfd_link_hash_undefweak
1630 || h
->root
.type
== bfd_link_hash_undefined
))))
1632 /* Make sure this symbol is output as a dynamic symbol.
1633 Undefined weak syms won't yet be marked as dynamic. */
1634 if (h
->dynindx
== -1
1635 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1637 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1641 /* If that succeeded, we know we'll be keeping all the
1643 if (h
->dynindx
!= -1)
1647 eh
->dyn_relocs
= NULL
;
1652 /* Finally, allocate space. */
1653 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1655 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1656 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1662 /* Find any dynamic relocs that apply to read-only sections. */
1665 readonly_dynrelocs (h
, inf
)
1666 struct elf_link_hash_entry
*h
;
1669 struct elf_i386_link_hash_entry
*eh
;
1670 struct elf_i386_dyn_relocs
*p
;
1672 if (h
->root
.type
== bfd_link_hash_warning
)
1673 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1675 eh
= (struct elf_i386_link_hash_entry
*) h
;
1676 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1678 asection
*s
= p
->sec
->output_section
;
1680 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1682 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1684 info
->flags
|= DF_TEXTREL
;
1686 /* Not an error, just cut short the traversal. */
1693 /* Set the sizes of the dynamic sections. */
1696 elf_i386_size_dynamic_sections (output_bfd
, info
)
1697 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1698 struct bfd_link_info
*info
;
1700 struct elf_i386_link_hash_table
*htab
;
1706 htab
= elf_i386_hash_table (info
);
1707 dynobj
= htab
->elf
.dynobj
;
1711 if (htab
->elf
.dynamic_sections_created
)
1713 /* Set the contents of the .interp section to the interpreter. */
1716 s
= bfd_get_section_by_name (dynobj
, ".interp");
1719 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1720 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1724 /* Set up .got offsets for local syms, and space for local dynamic
1726 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1728 bfd_signed_vma
*local_got
;
1729 bfd_signed_vma
*end_local_got
;
1730 char *local_tls_type
;
1731 bfd_size_type locsymcount
;
1732 Elf_Internal_Shdr
*symtab_hdr
;
1735 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1738 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1740 struct elf_i386_dyn_relocs
*p
;
1742 for (p
= *((struct elf_i386_dyn_relocs
**)
1743 &elf_section_data (s
)->local_dynrel
);
1747 if (!bfd_is_abs_section (p
->sec
)
1748 && bfd_is_abs_section (p
->sec
->output_section
))
1750 /* Input section has been discarded, either because
1751 it is a copy of a linkonce section or due to
1752 linker script /DISCARD/, so we'll be discarding
1755 else if (p
->count
!= 0)
1757 srel
= elf_section_data (p
->sec
)->sreloc
;
1758 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1759 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1760 info
->flags
|= DF_TEXTREL
;
1765 local_got
= elf_local_got_refcounts (ibfd
);
1769 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1770 locsymcount
= symtab_hdr
->sh_info
;
1771 end_local_got
= local_got
+ locsymcount
;
1772 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1774 srel
= htab
->srelgot
;
1775 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1779 *local_got
= s
->_raw_size
;
1781 if (*local_tls_type
== GOT_TLS_GD
)
1784 || *local_tls_type
== GOT_TLS_GD
1785 || *local_tls_type
== GOT_TLS_IE
)
1786 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1789 *local_got
= (bfd_vma
) -1;
1793 if (htab
->tls_ldm_got
.refcount
> 0)
1795 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1797 htab
->tls_ldm_got
.offset
= htab
->sgot
->_raw_size
;
1798 htab
->sgot
->_raw_size
+= 8;
1799 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1802 htab
->tls_ldm_got
.offset
= -1;
1804 /* Allocate global sym .plt and .got entries, and space for global
1805 sym dynamic relocs. */
1806 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1808 /* We now have determined the sizes of the various dynamic sections.
1809 Allocate memory for them. */
1811 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1813 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1818 || s
== htab
->sgotplt
)
1820 /* Strip this section if we don't need it; see the
1823 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1825 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1828 /* We use the reloc_count field as a counter if we need
1829 to copy relocs into the output file. */
1834 /* It's not one of our sections, so don't allocate space. */
1838 if (s
->_raw_size
== 0)
1840 /* If we don't need this section, strip it from the
1841 output file. This is mostly to handle .rel.bss and
1842 .rel.plt. We must create both sections in
1843 create_dynamic_sections, because they must be created
1844 before the linker maps input sections to output
1845 sections. The linker does that before
1846 adjust_dynamic_symbol is called, and it is that
1847 function which decides whether anything needs to go
1848 into these sections. */
1850 _bfd_strip_section_from_output (info
, s
);
1854 /* Allocate memory for the section contents. We use bfd_zalloc
1855 here in case unused entries are not reclaimed before the
1856 section's contents are written out. This should not happen,
1857 but this way if it does, we get a R_386_NONE reloc instead
1859 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1860 if (s
->contents
== NULL
)
1864 if (htab
->elf
.dynamic_sections_created
)
1866 /* Add some entries to the .dynamic section. We fill in the
1867 values later, in elf_i386_finish_dynamic_sections, but we
1868 must add the entries now so that we get the correct size for
1869 the .dynamic section. The DT_DEBUG entry is filled in by the
1870 dynamic linker and used by the debugger. */
1871 #define add_dynamic_entry(TAG, VAL) \
1872 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1876 if (!add_dynamic_entry (DT_DEBUG
, 0))
1880 if (htab
->splt
->_raw_size
!= 0)
1882 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1883 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1884 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1885 || !add_dynamic_entry (DT_JMPREL
, 0))
1891 if (!add_dynamic_entry (DT_REL
, 0)
1892 || !add_dynamic_entry (DT_RELSZ
, 0)
1893 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1896 /* If any dynamic relocs apply to a read-only section,
1897 then we need a DT_TEXTREL entry. */
1898 if ((info
->flags
& DF_TEXTREL
) == 0)
1899 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1902 if ((info
->flags
& DF_TEXTREL
) != 0)
1904 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1909 #undef add_dynamic_entry
1914 /* Set the correct type for an x86 ELF section. We do this by the
1915 section name, which is a hack, but ought to work. */
1918 elf_i386_fake_sections (abfd
, hdr
, sec
)
1919 bfd
*abfd ATTRIBUTE_UNUSED
;
1920 Elf32_Internal_Shdr
*hdr
;
1923 register const char *name
;
1925 name
= bfd_get_section_name (abfd
, sec
);
1927 /* This is an ugly, but unfortunately necessary hack that is
1928 needed when producing EFI binaries on x86. It tells
1929 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1930 containing ELF relocation info. We need this hack in order to
1931 be able to generate ELF binaries that can be translated into
1932 EFI applications (which are essentially COFF objects). Those
1933 files contain a COFF ".reloc" section inside an ELFNN object,
1934 which would normally cause BFD to segfault because it would
1935 attempt to interpret this section as containing relocation
1936 entries for section "oc". With this hack enabled, ".reloc"
1937 will be treated as a normal data section, which will avoid the
1938 segfault. However, you won't be able to create an ELFNN binary
1939 with a section named "oc" that needs relocations, but that's
1940 the kind of ugly side-effects you get when detecting section
1941 types based on their names... In practice, this limitation is
1942 unlikely to bite. */
1943 if (strcmp (name
, ".reloc") == 0)
1944 hdr
->sh_type
= SHT_PROGBITS
;
1949 /* Return the base VMA address which should be subtracted from real addresses
1950 when resolving @dtpoff relocation.
1951 This is PT_TLS segment p_vaddr. */
1955 struct bfd_link_info
*info
;
1957 BFD_ASSERT (elf_hash_table (info
)->tls_segment
!= NULL
);
1958 return elf_hash_table (info
)->tls_segment
->start
;
1961 /* Return the relocation value for @tpoff relocation
1962 if STT_TLS virtual address is ADDRESS. */
1965 tpoff (info
, address
)
1966 struct bfd_link_info
*info
;
1969 struct elf_link_tls_segment
*tls_segment
1970 = elf_hash_table (info
)->tls_segment
;
1972 BFD_ASSERT (tls_segment
!= NULL
);
1973 return (align_power (tls_segment
->size
, tls_segment
->align
)
1974 + tls_segment
->start
- address
);
1977 /* Relocate an i386 ELF section. */
1980 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1981 contents
, relocs
, local_syms
, local_sections
)
1983 struct bfd_link_info
*info
;
1985 asection
*input_section
;
1987 Elf_Internal_Rela
*relocs
;
1988 Elf_Internal_Sym
*local_syms
;
1989 asection
**local_sections
;
1991 struct elf_i386_link_hash_table
*htab
;
1992 Elf_Internal_Shdr
*symtab_hdr
;
1993 struct elf_link_hash_entry
**sym_hashes
;
1994 bfd_vma
*local_got_offsets
;
1995 Elf_Internal_Rela
*rel
;
1996 Elf_Internal_Rela
*relend
;
1998 htab
= elf_i386_hash_table (info
);
1999 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2000 sym_hashes
= elf_sym_hashes (input_bfd
);
2001 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2004 relend
= relocs
+ input_section
->reloc_count
;
2005 for (; rel
< relend
; rel
++)
2007 unsigned int r_type
;
2008 reloc_howto_type
*howto
;
2009 unsigned long r_symndx
;
2010 struct elf_link_hash_entry
*h
;
2011 Elf_Internal_Sym
*sym
;
2015 boolean unresolved_reloc
;
2016 bfd_reloc_status_type r
;
2020 r_type
= ELF32_R_TYPE (rel
->r_info
);
2021 if (r_type
== (int) R_386_GNU_VTINHERIT
2022 || r_type
== (int) R_386_GNU_VTENTRY
)
2025 if ((indx
= (unsigned) r_type
) >= R_386_standard
2026 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2027 >= R_386_ext
- R_386_standard
)
2028 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2029 >= R_386_tls
- R_386_ext
))
2031 bfd_set_error (bfd_error_bad_value
);
2034 howto
= elf_howto_table
+ indx
;
2036 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2038 if (info
->relocateable
)
2043 /* This is a relocatable link. We don't have to change
2044 anything, unless the reloc is against a section symbol,
2045 in which case we have to adjust according to where the
2046 section symbol winds up in the output section. */
2047 if (r_symndx
>= symtab_hdr
->sh_info
)
2050 sym
= local_syms
+ r_symndx
;
2051 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2054 sec
= local_sections
[r_symndx
];
2055 val
= sec
->output_offset
;
2059 where
= contents
+ rel
->r_offset
;
2060 switch (howto
->size
)
2062 /* FIXME: overflow checks. */
2064 val
+= bfd_get_8 (input_bfd
, where
);
2065 bfd_put_8 (input_bfd
, val
, where
);
2068 val
+= bfd_get_16 (input_bfd
, where
);
2069 bfd_put_16 (input_bfd
, val
, where
);
2072 val
+= bfd_get_32 (input_bfd
, where
);
2073 bfd_put_32 (input_bfd
, val
, where
);
2081 /* This is a final link. */
2085 unresolved_reloc
= false;
2086 if (r_symndx
< symtab_hdr
->sh_info
)
2088 sym
= local_syms
+ r_symndx
;
2089 sec
= local_sections
[r_symndx
];
2090 relocation
= (sec
->output_section
->vma
2091 + sec
->output_offset
2093 if ((sec
->flags
& SEC_MERGE
)
2094 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2098 bfd_byte
*where
= contents
+ rel
->r_offset
;
2100 switch (howto
->size
)
2103 addend
= bfd_get_8 (input_bfd
, where
);
2104 if (howto
->pc_relative
)
2106 addend
= (addend
^ 0x80) - 0x80;
2111 addend
= bfd_get_16 (input_bfd
, where
);
2112 if (howto
->pc_relative
)
2114 addend
= (addend
^ 0x8000) - 0x8000;
2119 addend
= bfd_get_32 (input_bfd
, where
);
2120 if (howto
->pc_relative
)
2122 addend
= (addend
^ 0x80000000) - 0x80000000;
2131 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2132 addend
-= relocation
;
2133 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2135 switch (howto
->size
)
2138 /* FIXME: overflow checks. */
2139 if (howto
->pc_relative
)
2141 bfd_put_8 (input_bfd
, addend
, where
);
2144 if (howto
->pc_relative
)
2146 bfd_put_16 (input_bfd
, addend
, where
);
2149 if (howto
->pc_relative
)
2151 bfd_put_32 (input_bfd
, addend
, where
);
2158 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2159 while (h
->root
.type
== bfd_link_hash_indirect
2160 || h
->root
.type
== bfd_link_hash_warning
)
2161 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2164 if (h
->root
.type
== bfd_link_hash_defined
2165 || h
->root
.type
== bfd_link_hash_defweak
)
2167 sec
= h
->root
.u
.def
.section
;
2168 if (sec
->output_section
== NULL
)
2169 /* Set a flag that will be cleared later if we find a
2170 relocation value for this symbol. output_section
2171 is typically NULL for symbols satisfied by a shared
2173 unresolved_reloc
= true;
2175 relocation
= (h
->root
.u
.def
.value
2176 + sec
->output_section
->vma
2177 + sec
->output_offset
);
2179 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2181 else if (info
->shared
2182 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
2183 && !info
->no_undefined
2184 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2188 if (! ((*info
->callbacks
->undefined_symbol
)
2189 (info
, h
->root
.root
.string
, input_bfd
,
2190 input_section
, rel
->r_offset
,
2191 (!info
->shared
|| info
->no_undefined
2192 || ELF_ST_VISIBILITY (h
->other
)))))
2200 /* Relocation is to the entry for this symbol in the global
2202 if (htab
->sgot
== NULL
)
2209 off
= h
->got
.offset
;
2210 dyn
= htab
->elf
.dynamic_sections_created
;
2211 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
2215 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2216 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
2218 /* This is actually a static link, or it is a
2219 -Bsymbolic link and the symbol is defined
2220 locally, or the symbol was forced to be local
2221 because of a version file. We must initialize
2222 this entry in the global offset table. Since the
2223 offset must always be a multiple of 4, we use the
2224 least significant bit to record whether we have
2225 initialized it already.
2227 When doing a dynamic link, we create a .rel.got
2228 relocation entry to initialize the value. This
2229 is done in the finish_dynamic_symbol routine. */
2234 bfd_put_32 (output_bfd
, relocation
,
2235 htab
->sgot
->contents
+ off
);
2240 unresolved_reloc
= false;
2244 if (local_got_offsets
== NULL
)
2247 off
= local_got_offsets
[r_symndx
];
2249 /* The offset must always be a multiple of 4. We use
2250 the least significant bit to record whether we have
2251 already generated the necessary reloc. */
2256 bfd_put_32 (output_bfd
, relocation
,
2257 htab
->sgot
->contents
+ off
);
2262 Elf_Internal_Rel outrel
;
2263 Elf32_External_Rel
*loc
;
2265 srelgot
= htab
->srelgot
;
2266 if (srelgot
== NULL
)
2269 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2270 + htab
->sgot
->output_offset
2272 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2273 loc
= (Elf32_External_Rel
*) srelgot
->contents
;
2274 loc
+= srelgot
->reloc_count
++;
2275 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2278 local_got_offsets
[r_symndx
] |= 1;
2282 if (off
>= (bfd_vma
) -2)
2285 relocation
= htab
->sgot
->output_offset
+ off
;
2289 /* Relocation is relative to the start of the global offset
2292 /* Note that sgot->output_offset is not involved in this
2293 calculation. We always want the start of .got. If we
2294 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2295 permitted by the ABI, we might have to change this
2297 relocation
-= htab
->sgot
->output_section
->vma
;
2301 /* Use global offset table as symbol value. */
2302 relocation
= htab
->sgot
->output_section
->vma
;
2303 unresolved_reloc
= false;
2307 /* Relocation is to the entry for this symbol in the
2308 procedure linkage table. */
2310 /* Resolve a PLT32 reloc against a local symbol directly,
2311 without using the procedure linkage table. */
2315 if (h
->plt
.offset
== (bfd_vma
) -1
2316 || htab
->splt
== NULL
)
2318 /* We didn't make a PLT entry for this symbol. This
2319 happens when statically linking PIC code, or when
2320 using -Bsymbolic. */
2324 relocation
= (htab
->splt
->output_section
->vma
2325 + htab
->splt
->output_offset
2327 unresolved_reloc
= false;
2332 /* r_symndx will be zero only for relocs against symbols
2333 from removed linkonce sections, or sections discarded by
2336 || (input_section
->flags
& SEC_ALLOC
) == 0)
2340 && (r_type
!= R_386_PC32
2343 && (! info
->symbolic
2344 || (h
->elf_link_hash_flags
2345 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2349 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2350 && (((h
->elf_link_hash_flags
2351 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2352 && (h
->elf_link_hash_flags
2353 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
2354 || h
->root
.type
== bfd_link_hash_undefweak
2355 || h
->root
.type
== bfd_link_hash_undefined
)))
2357 Elf_Internal_Rel outrel
;
2358 boolean skip
, relocate
;
2360 Elf32_External_Rel
*loc
;
2362 /* When generating a shared object, these relocations
2363 are copied into the output file to be resolved at run
2370 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2372 if (outrel
.r_offset
== (bfd_vma
) -1)
2374 else if (outrel
.r_offset
== (bfd_vma
) -2)
2375 skip
= true, relocate
= true;
2376 outrel
.r_offset
+= (input_section
->output_section
->vma
2377 + input_section
->output_offset
);
2380 memset (&outrel
, 0, sizeof outrel
);
2383 && (r_type
== R_386_PC32
2386 || (h
->elf_link_hash_flags
2387 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2388 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2391 /* This symbol is local, or marked to become local. */
2393 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2396 sreloc
= elf_section_data (input_section
)->sreloc
;
2400 loc
= (Elf32_External_Rel
*) sreloc
->contents
;
2401 loc
+= sreloc
->reloc_count
++;
2402 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2404 /* If this reloc is against an external symbol, we do
2405 not want to fiddle with the addend. Otherwise, we
2406 need to include the symbol value so that it becomes
2407 an addend for the dynamic reloc. */
2414 case R_386_TLS_IE_32
:
2415 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2416 tls_type
= GOT_UNKNOWN
;
2417 if (h
== NULL
&& local_got_offsets
)
2418 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2421 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2422 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2423 r_type
= R_386_TLS_LE_32
;
2425 if (r_type
== R_386_TLS_GD
&& tls_type
== GOT_TLS_IE
)
2426 r_type
= R_386_TLS_IE_32
;
2428 if (r_type
== R_386_TLS_LE_32
)
2430 BFD_ASSERT (! unresolved_reloc
);
2431 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2433 unsigned int val
, type
;
2436 /* GD->LE transition. */
2437 BFD_ASSERT (rel
->r_offset
>= 2);
2438 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2439 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2440 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2441 BFD_ASSERT (bfd_get_8 (input_bfd
,
2442 contents
+ rel
->r_offset
+ 4)
2444 BFD_ASSERT (rel
+ 1 < relend
);
2445 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2446 roff
= rel
->r_offset
+ 5;
2447 val
= bfd_get_8 (input_bfd
,
2448 contents
+ rel
->r_offset
- 1);
2451 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2453 movl %gs:0, %eax; subl $foo@tpoff, %eax
2454 (6 byte form of subl). */
2455 BFD_ASSERT (rel
->r_offset
>= 3);
2456 BFD_ASSERT (bfd_get_8 (input_bfd
,
2457 contents
+ rel
->r_offset
- 3)
2459 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2460 memcpy (contents
+ rel
->r_offset
- 3,
2461 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2465 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2466 if (rel
->r_offset
+ 10 <= input_section
->_raw_size
2467 && bfd_get_8 (input_bfd
,
2468 contents
+ rel
->r_offset
+ 9) == 0x90)
2470 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2472 movl %gs:0, %eax; subl $foo@tpoff, %eax
2473 (6 byte form of subl). */
2474 memcpy (contents
+ rel
->r_offset
- 2,
2475 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2476 roff
= rel
->r_offset
+ 6;
2480 /* leal foo(%reg), %eax; call ___tls_get_addr
2482 movl %gs:0, %eax; subl $foo@tpoff, %eax
2483 (5 byte form of subl). */
2484 memcpy (contents
+ rel
->r_offset
- 2,
2485 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2488 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2490 /* Skip R_386_PLT32. */
2496 unsigned int val
, type
;
2498 /* IE->LE transition:
2499 Originally it can be either:
2500 subl foo(%reg1), %reg2
2502 movl foo(%reg1), %reg2
2506 movl $foo, %reg2 (6 byte form) */
2507 BFD_ASSERT (rel
->r_offset
>= 2);
2508 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2509 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2510 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->_raw_size
);
2514 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2515 bfd_put_8 (output_bfd
, 0xc7,
2516 contents
+ rel
->r_offset
- 2);
2517 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2518 contents
+ rel
->r_offset
- 1);
2520 else if (type
== 0x2b)
2523 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2524 bfd_put_8 (output_bfd
, 0x81,
2525 contents
+ rel
->r_offset
- 2);
2526 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2527 contents
+ rel
->r_offset
- 1);
2531 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2532 contents
+ rel
->r_offset
);
2537 if (htab
->sgot
== NULL
)
2541 off
= h
->got
.offset
;
2544 if (local_got_offsets
== NULL
)
2547 off
= local_got_offsets
[r_symndx
];
2554 Elf_Internal_Rel outrel
;
2555 Elf32_External_Rel
*loc
;
2558 if (htab
->srelgot
== NULL
)
2561 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2562 + htab
->sgot
->output_offset
+ off
);
2564 bfd_put_32 (output_bfd
, 0,
2565 htab
->sgot
->contents
+ off
);
2566 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2567 if (r_type
== R_386_TLS_GD
)
2568 dr_type
= R_386_TLS_DTPMOD32
;
2570 dr_type
= R_386_TLS_TPOFF32
;
2571 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
2572 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2573 loc
+= htab
->srelgot
->reloc_count
++;
2574 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2576 if (r_type
== R_386_TLS_GD
)
2580 BFD_ASSERT (! unresolved_reloc
);
2581 bfd_put_32 (output_bfd
,
2582 relocation
- dtpoff_base (info
),
2583 htab
->sgot
->contents
+ off
+ 4);
2587 bfd_put_32 (output_bfd
, 0,
2588 htab
->sgot
->contents
+ off
+ 4);
2589 outrel
.r_info
= ELF32_R_INFO (indx
,
2590 R_386_TLS_DTPOFF32
);
2591 outrel
.r_offset
+= 4;
2592 htab
->srelgot
->reloc_count
++;
2594 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
2602 local_got_offsets
[r_symndx
] |= 1;
2605 if (off
>= (bfd_vma
) -2)
2607 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
2609 relocation
= htab
->sgot
->output_offset
+ off
;
2610 unresolved_reloc
= false;
2614 unsigned int val
, type
;
2617 /* GD->IE transition. */
2618 BFD_ASSERT (rel
->r_offset
>= 2);
2619 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2620 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2621 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2622 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2624 BFD_ASSERT (rel
+ 1 < relend
);
2625 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2626 roff
= rel
->r_offset
- 3;
2627 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2630 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2632 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2633 BFD_ASSERT (rel
->r_offset
>= 3);
2634 BFD_ASSERT (bfd_get_8 (input_bfd
,
2635 contents
+ rel
->r_offset
- 3)
2637 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2642 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2644 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2645 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->_raw_size
);
2646 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2647 BFD_ASSERT (bfd_get_8 (input_bfd
,
2648 contents
+ rel
->r_offset
+ 9)
2650 roff
= rel
->r_offset
- 2;
2652 memcpy (contents
+ roff
,
2653 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2654 contents
[roff
+ 7] = 0x80 | (val
& 7);
2655 bfd_put_32 (output_bfd
, htab
->sgot
->output_offset
+ off
,
2656 contents
+ roff
+ 8);
2657 /* Skip R_386_PLT32. */
2668 /* LD->LE transition:
2670 leal foo(%reg), %eax; call ___tls_get_addr.
2672 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2673 BFD_ASSERT (rel
->r_offset
>= 2);
2674 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
2676 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2677 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2678 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2679 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2681 BFD_ASSERT (rel
+ 1 < relend
);
2682 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2683 memcpy (contents
+ rel
->r_offset
- 2,
2684 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2685 /* Skip R_386_PLT32. */
2690 if (htab
->sgot
== NULL
)
2693 off
= htab
->tls_ldm_got
.offset
;
2698 Elf_Internal_Rel outrel
;
2699 Elf32_External_Rel
*loc
;
2701 if (htab
->srelgot
== NULL
)
2704 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2705 + htab
->sgot
->output_offset
+ off
);
2707 bfd_put_32 (output_bfd
, 0,
2708 htab
->sgot
->contents
+ off
);
2709 bfd_put_32 (output_bfd
, 0,
2710 htab
->sgot
->contents
+ off
+ 4);
2711 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
2712 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2713 loc
+= htab
->srelgot
->reloc_count
++;
2714 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2715 htab
->tls_ldm_got
.offset
|= 1;
2717 relocation
= htab
->sgot
->output_offset
+ off
;
2718 unresolved_reloc
= false;
2721 case R_386_TLS_LDO_32
:
2723 relocation
-= dtpoff_base (info
);
2725 /* When converting LDO to LE, we must negate. */
2726 relocation
= -tpoff (info
, relocation
);
2729 case R_386_TLS_LE_32
:
2730 relocation
= tpoff (info
, relocation
);
2734 relocation
= -tpoff (info
, relocation
);
2741 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2742 because such sections are not SEC_ALLOC and thus ld.so will
2743 not process them. */
2744 if (unresolved_reloc
2745 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2746 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2747 (*_bfd_error_handler
)
2748 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2749 bfd_archive_filename (input_bfd
),
2750 bfd_get_section_name (input_bfd
, input_section
),
2751 (long) rel
->r_offset
,
2752 h
->root
.root
.string
);
2754 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2755 contents
, rel
->r_offset
,
2756 relocation
, (bfd_vma
) 0);
2758 if (r
!= bfd_reloc_ok
)
2763 name
= h
->root
.root
.string
;
2766 name
= bfd_elf_string_from_elf_section (input_bfd
,
2767 symtab_hdr
->sh_link
,
2772 name
= bfd_section_name (input_bfd
, sec
);
2775 if (r
== bfd_reloc_overflow
)
2777 if (! ((*info
->callbacks
->reloc_overflow
)
2778 (info
, name
, howto
->name
, (bfd_vma
) 0,
2779 input_bfd
, input_section
, rel
->r_offset
)))
2784 (*_bfd_error_handler
)
2785 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2786 bfd_archive_filename (input_bfd
),
2787 bfd_get_section_name (input_bfd
, input_section
),
2788 (long) rel
->r_offset
, name
, (int) r
);
2797 /* Finish up dynamic symbol handling. We set the contents of various
2798 dynamic sections here. */
2801 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2803 struct bfd_link_info
*info
;
2804 struct elf_link_hash_entry
*h
;
2805 Elf_Internal_Sym
*sym
;
2807 struct elf_i386_link_hash_table
*htab
;
2809 htab
= elf_i386_hash_table (info
);
2811 if (h
->plt
.offset
!= (bfd_vma
) -1)
2815 Elf_Internal_Rel rel
;
2816 Elf32_External_Rel
*loc
;
2818 /* This symbol has an entry in the procedure linkage table. Set
2821 if (h
->dynindx
== -1
2822 || htab
->splt
== NULL
2823 || htab
->sgotplt
== NULL
2824 || htab
->srelplt
== NULL
)
2827 /* Get the index in the procedure linkage table which
2828 corresponds to this symbol. This is the index of this symbol
2829 in all the symbols for which we are making plt entries. The
2830 first entry in the procedure linkage table is reserved. */
2831 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2833 /* Get the offset into the .got table of the entry that
2834 corresponds to this function. Each .got entry is 4 bytes.
2835 The first three are reserved. */
2836 got_offset
= (plt_index
+ 3) * 4;
2838 /* Fill in the entry in the procedure linkage table. */
2841 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
2843 bfd_put_32 (output_bfd
,
2844 (htab
->sgotplt
->output_section
->vma
2845 + htab
->sgotplt
->output_offset
2847 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2851 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
2853 bfd_put_32 (output_bfd
, got_offset
,
2854 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2857 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
2858 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2859 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2860 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2862 /* Fill in the entry in the global offset table. */
2863 bfd_put_32 (output_bfd
,
2864 (htab
->splt
->output_section
->vma
2865 + htab
->splt
->output_offset
2868 htab
->sgotplt
->contents
+ got_offset
);
2870 /* Fill in the entry in the .rel.plt section. */
2871 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2872 + htab
->sgotplt
->output_offset
2874 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
2875 loc
= (Elf32_External_Rel
*) htab
->srelplt
->contents
+ plt_index
;
2876 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2878 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2880 /* Mark the symbol as undefined, rather than as defined in
2881 the .plt section. Leave the value alone. This is a clue
2882 for the dynamic linker, to make function pointer
2883 comparisons work between an application and shared
2885 sym
->st_shndx
= SHN_UNDEF
;
2889 if (h
->got
.offset
!= (bfd_vma
) -1
2890 && elf_i386_hash_entry(h
)->tls_type
!= GOT_TLS_GD
2891 && elf_i386_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
2893 Elf_Internal_Rel rel
;
2894 Elf32_External_Rel
*loc
;
2896 /* This symbol has an entry in the global offset table. Set it
2899 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2902 rel
.r_offset
= (htab
->sgot
->output_section
->vma
2903 + htab
->sgot
->output_offset
2904 + (h
->got
.offset
& ~(bfd_vma
) 1));
2906 /* If this is a static link, or it is a -Bsymbolic link and the
2907 symbol is defined locally or was forced to be local because
2908 of a version file, we just want to emit a RELATIVE reloc.
2909 The entry in the global offset table will already have been
2910 initialized in the relocate_section function. */
2914 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2915 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2917 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2918 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2922 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2923 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2924 htab
->sgot
->contents
+ h
->got
.offset
);
2925 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2928 loc
= (Elf32_External_Rel
*) htab
->srelgot
->contents
;
2929 loc
+= htab
->srelgot
->reloc_count
++;
2930 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2933 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2935 Elf_Internal_Rel rel
;
2936 Elf32_External_Rel
*loc
;
2938 /* This symbol needs a copy reloc. Set it up. */
2940 if (h
->dynindx
== -1
2941 || (h
->root
.type
!= bfd_link_hash_defined
2942 && h
->root
.type
!= bfd_link_hash_defweak
)
2943 || htab
->srelbss
== NULL
)
2946 rel
.r_offset
= (h
->root
.u
.def
.value
2947 + h
->root
.u
.def
.section
->output_section
->vma
2948 + h
->root
.u
.def
.section
->output_offset
);
2949 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2950 loc
= (Elf32_External_Rel
*) htab
->srelbss
->contents
;
2951 loc
+= htab
->srelbss
->reloc_count
++;
2952 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
2955 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2956 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2957 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2958 sym
->st_shndx
= SHN_ABS
;
2963 /* Used to decide how to sort relocs in an optimal manner for the
2964 dynamic linker, before writing them out. */
2966 static enum elf_reloc_type_class
2967 elf_i386_reloc_type_class (rela
)
2968 const Elf_Internal_Rela
*rela
;
2970 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2972 case R_386_RELATIVE
:
2973 return reloc_class_relative
;
2974 case R_386_JUMP_SLOT
:
2975 return reloc_class_plt
;
2977 return reloc_class_copy
;
2979 return reloc_class_normal
;
2983 /* Finish up the dynamic sections. */
2986 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2988 struct bfd_link_info
*info
;
2990 struct elf_i386_link_hash_table
*htab
;
2994 htab
= elf_i386_hash_table (info
);
2995 dynobj
= htab
->elf
.dynobj
;
2996 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2998 if (htab
->elf
.dynamic_sections_created
)
3000 Elf32_External_Dyn
*dyncon
, *dynconend
;
3002 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3005 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3006 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3007 for (; dyncon
< dynconend
; dyncon
++)
3009 Elf_Internal_Dyn dyn
;
3012 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3020 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
3024 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
3028 s
= htab
->srelplt
->output_section
;
3029 if (s
->_cooked_size
!= 0)
3030 dyn
.d_un
.d_val
= s
->_cooked_size
;
3032 dyn
.d_un
.d_val
= s
->_raw_size
;
3036 /* My reading of the SVR4 ABI indicates that the
3037 procedure linkage table relocs (DT_JMPREL) should be
3038 included in the overall relocs (DT_REL). This is
3039 what Solaris does. However, UnixWare can not handle
3040 that case. Therefore, we override the DT_RELSZ entry
3041 here to make it not include the JMPREL relocs. Since
3042 the linker script arranges for .rel.plt to follow all
3043 other relocation sections, we don't have to worry
3044 about changing the DT_REL entry. */
3045 if (htab
->srelplt
!= NULL
)
3047 s
= htab
->srelplt
->output_section
;
3048 if (s
->_cooked_size
!= 0)
3049 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3051 dyn
.d_un
.d_val
-= s
->_raw_size
;
3056 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3059 /* Fill in the first entry in the procedure linkage table. */
3060 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
3063 memcpy (htab
->splt
->contents
,
3064 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
3067 memcpy (htab
->splt
->contents
,
3068 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
3069 bfd_put_32 (output_bfd
,
3070 (htab
->sgotplt
->output_section
->vma
3071 + htab
->sgotplt
->output_offset
3073 htab
->splt
->contents
+ 2);
3074 bfd_put_32 (output_bfd
,
3075 (htab
->sgotplt
->output_section
->vma
3076 + htab
->sgotplt
->output_offset
3078 htab
->splt
->contents
+ 8);
3081 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3082 really seem like the right value. */
3083 elf_section_data (htab
->splt
->output_section
)
3084 ->this_hdr
.sh_entsize
= 4;
3090 /* Fill in the first three entries in the global offset table. */
3091 if (htab
->sgotplt
->_raw_size
> 0)
3093 bfd_put_32 (output_bfd
,
3094 (sdyn
== NULL
? (bfd_vma
) 0
3095 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3096 htab
->sgotplt
->contents
);
3097 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
3098 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
3101 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3106 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3107 #define TARGET_LITTLE_NAME "elf32-i386"
3108 #define ELF_ARCH bfd_arch_i386
3109 #define ELF_MACHINE_CODE EM_386
3110 #define ELF_MAXPAGESIZE 0x1000
3112 #define elf_backend_can_gc_sections 1
3113 #define elf_backend_can_refcount 1
3114 #define elf_backend_want_got_plt 1
3115 #define elf_backend_plt_readonly 1
3116 #define elf_backend_want_plt_sym 0
3117 #define elf_backend_got_header_size 12
3118 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3120 #define elf_info_to_howto elf_i386_info_to_howto
3121 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3123 #define bfd_elf32_mkobject elf_i386_mkobject
3124 #define elf_backend_object_p elf_i386_object_p
3126 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3127 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3128 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3130 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3131 #define elf_backend_check_relocs elf_i386_check_relocs
3132 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3133 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3134 #define elf_backend_fake_sections elf_i386_fake_sections
3135 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3136 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3137 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3138 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3139 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3140 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3141 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3142 #define elf_backend_relocate_section elf_i386_relocate_section
3143 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3145 #ifndef ELF32_I386_C_INCLUDED
3146 #include "elf32-target.h"