1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
26 #include "elf-vxworks.h"
28 /* 386 uses REL relocations instead of RELA. */
33 static reloc_howto_type elf_howto_table
[]=
35 HOWTO(R_386_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_bitfield
,
36 bfd_elf_generic_reloc
, "R_386_NONE",
37 TRUE
, 0x00000000, 0x00000000, FALSE
),
38 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
39 bfd_elf_generic_reloc
, "R_386_32",
40 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
41 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
42 bfd_elf_generic_reloc
, "R_386_PC32",
43 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
44 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
45 bfd_elf_generic_reloc
, "R_386_GOT32",
46 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
47 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
48 bfd_elf_generic_reloc
, "R_386_PLT32",
49 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
50 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
51 bfd_elf_generic_reloc
, "R_386_COPY",
52 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
53 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
55 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
56 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
57 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
58 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
59 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
60 bfd_elf_generic_reloc
, "R_386_RELATIVE",
61 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
62 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_386_GOTOFF",
64 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
65 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_386_GOTPC",
67 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
69 /* We have a gap in the reloc numbers here.
70 R_386_standard counts the number up to this point, and
71 R_386_ext_offset is the value to subtract from a reloc type of
72 R_386_16 thru R_386_PC8 to form an index into this table. */
73 #define R_386_standard (R_386_GOTPC + 1)
74 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
76 /* These relocs are a GNU extension. */
77 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
78 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
79 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
80 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
81 bfd_elf_generic_reloc
, "R_386_TLS_IE",
82 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
83 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
85 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
86 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_386_TLS_LE",
88 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
89 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_386_TLS_GD",
91 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
92 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
94 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
95 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_386_16",
97 TRUE
, 0xffff, 0xffff, FALSE
),
98 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_386_PC16",
100 TRUE
, 0xffff, 0xffff, TRUE
),
101 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_386_8",
103 TRUE
, 0xff, 0xff, FALSE
),
104 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
105 bfd_elf_generic_reloc
, "R_386_PC8",
106 TRUE
, 0xff, 0xff, TRUE
),
108 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
109 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
110 /* These are common with Solaris TLS implementation. */
111 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
112 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
113 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
114 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
115 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
116 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
117 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
118 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
119 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
120 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
121 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
122 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
123 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
124 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
125 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
126 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
128 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
130 HOWTO(R_386_TLS_GOTDESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
131 bfd_elf_generic_reloc
, "R_386_TLS_GOTDESC",
132 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
133 HOWTO(R_386_TLS_DESC_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
134 bfd_elf_generic_reloc
, "R_386_TLS_DESC_CALL",
136 HOWTO(R_386_TLS_DESC
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
137 bfd_elf_generic_reloc
, "R_386_TLS_DESC",
138 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
141 #define R_386_tls (R_386_TLS_DESC + 1 - R_386_tls_offset)
142 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
144 /* GNU extension to record C++ vtable hierarchy. */
145 HOWTO (R_386_GNU_VTINHERIT
, /* type */
147 2, /* size (0 = byte, 1 = short, 2 = long) */
149 FALSE
, /* pc_relative */
151 complain_overflow_dont
, /* complain_on_overflow */
152 NULL
, /* special_function */
153 "R_386_GNU_VTINHERIT", /* name */
154 FALSE
, /* partial_inplace */
157 FALSE
), /* pcrel_offset */
159 /* GNU extension to record C++ vtable member usage. */
160 HOWTO (R_386_GNU_VTENTRY
, /* type */
162 2, /* size (0 = byte, 1 = short, 2 = long) */
164 FALSE
, /* pc_relative */
166 complain_overflow_dont
, /* complain_on_overflow */
167 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
168 "R_386_GNU_VTENTRY", /* name */
169 FALSE
, /* partial_inplace */
172 FALSE
) /* pcrel_offset */
174 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
178 #ifdef DEBUG_GEN_RELOC
180 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
185 static reloc_howto_type
*
186 elf_i386_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
187 bfd_reloc_code_real_type code
)
192 TRACE ("BFD_RELOC_NONE");
193 return &elf_howto_table
[R_386_NONE
];
196 TRACE ("BFD_RELOC_32");
197 return &elf_howto_table
[R_386_32
];
200 TRACE ("BFD_RELOC_CTOR");
201 return &elf_howto_table
[R_386_32
];
203 case BFD_RELOC_32_PCREL
:
204 TRACE ("BFD_RELOC_PC32");
205 return &elf_howto_table
[R_386_PC32
];
207 case BFD_RELOC_386_GOT32
:
208 TRACE ("BFD_RELOC_386_GOT32");
209 return &elf_howto_table
[R_386_GOT32
];
211 case BFD_RELOC_386_PLT32
:
212 TRACE ("BFD_RELOC_386_PLT32");
213 return &elf_howto_table
[R_386_PLT32
];
215 case BFD_RELOC_386_COPY
:
216 TRACE ("BFD_RELOC_386_COPY");
217 return &elf_howto_table
[R_386_COPY
];
219 case BFD_RELOC_386_GLOB_DAT
:
220 TRACE ("BFD_RELOC_386_GLOB_DAT");
221 return &elf_howto_table
[R_386_GLOB_DAT
];
223 case BFD_RELOC_386_JUMP_SLOT
:
224 TRACE ("BFD_RELOC_386_JUMP_SLOT");
225 return &elf_howto_table
[R_386_JUMP_SLOT
];
227 case BFD_RELOC_386_RELATIVE
:
228 TRACE ("BFD_RELOC_386_RELATIVE");
229 return &elf_howto_table
[R_386_RELATIVE
];
231 case BFD_RELOC_386_GOTOFF
:
232 TRACE ("BFD_RELOC_386_GOTOFF");
233 return &elf_howto_table
[R_386_GOTOFF
];
235 case BFD_RELOC_386_GOTPC
:
236 TRACE ("BFD_RELOC_386_GOTPC");
237 return &elf_howto_table
[R_386_GOTPC
];
239 /* These relocs are a GNU extension. */
240 case BFD_RELOC_386_TLS_TPOFF
:
241 TRACE ("BFD_RELOC_386_TLS_TPOFF");
242 return &elf_howto_table
[R_386_TLS_TPOFF
- R_386_ext_offset
];
244 case BFD_RELOC_386_TLS_IE
:
245 TRACE ("BFD_RELOC_386_TLS_IE");
246 return &elf_howto_table
[R_386_TLS_IE
- R_386_ext_offset
];
248 case BFD_RELOC_386_TLS_GOTIE
:
249 TRACE ("BFD_RELOC_386_TLS_GOTIE");
250 return &elf_howto_table
[R_386_TLS_GOTIE
- R_386_ext_offset
];
252 case BFD_RELOC_386_TLS_LE
:
253 TRACE ("BFD_RELOC_386_TLS_LE");
254 return &elf_howto_table
[R_386_TLS_LE
- R_386_ext_offset
];
256 case BFD_RELOC_386_TLS_GD
:
257 TRACE ("BFD_RELOC_386_TLS_GD");
258 return &elf_howto_table
[R_386_TLS_GD
- R_386_ext_offset
];
260 case BFD_RELOC_386_TLS_LDM
:
261 TRACE ("BFD_RELOC_386_TLS_LDM");
262 return &elf_howto_table
[R_386_TLS_LDM
- R_386_ext_offset
];
265 TRACE ("BFD_RELOC_16");
266 return &elf_howto_table
[R_386_16
- R_386_ext_offset
];
268 case BFD_RELOC_16_PCREL
:
269 TRACE ("BFD_RELOC_16_PCREL");
270 return &elf_howto_table
[R_386_PC16
- R_386_ext_offset
];
273 TRACE ("BFD_RELOC_8");
274 return &elf_howto_table
[R_386_8
- R_386_ext_offset
];
276 case BFD_RELOC_8_PCREL
:
277 TRACE ("BFD_RELOC_8_PCREL");
278 return &elf_howto_table
[R_386_PC8
- R_386_ext_offset
];
280 /* Common with Sun TLS implementation. */
281 case BFD_RELOC_386_TLS_LDO_32
:
282 TRACE ("BFD_RELOC_386_TLS_LDO_32");
283 return &elf_howto_table
[R_386_TLS_LDO_32
- R_386_tls_offset
];
285 case BFD_RELOC_386_TLS_IE_32
:
286 TRACE ("BFD_RELOC_386_TLS_IE_32");
287 return &elf_howto_table
[R_386_TLS_IE_32
- R_386_tls_offset
];
289 case BFD_RELOC_386_TLS_LE_32
:
290 TRACE ("BFD_RELOC_386_TLS_LE_32");
291 return &elf_howto_table
[R_386_TLS_LE_32
- R_386_tls_offset
];
293 case BFD_RELOC_386_TLS_DTPMOD32
:
294 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
295 return &elf_howto_table
[R_386_TLS_DTPMOD32
- R_386_tls_offset
];
297 case BFD_RELOC_386_TLS_DTPOFF32
:
298 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
299 return &elf_howto_table
[R_386_TLS_DTPOFF32
- R_386_tls_offset
];
301 case BFD_RELOC_386_TLS_TPOFF32
:
302 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
303 return &elf_howto_table
[R_386_TLS_TPOFF32
- R_386_tls_offset
];
305 case BFD_RELOC_386_TLS_GOTDESC
:
306 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
307 return &elf_howto_table
[R_386_TLS_GOTDESC
- R_386_tls_offset
];
309 case BFD_RELOC_386_TLS_DESC_CALL
:
310 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
311 return &elf_howto_table
[R_386_TLS_DESC_CALL
- R_386_tls_offset
];
313 case BFD_RELOC_386_TLS_DESC
:
314 TRACE ("BFD_RELOC_386_TLS_DESC");
315 return &elf_howto_table
[R_386_TLS_DESC
- R_386_tls_offset
];
317 case BFD_RELOC_VTABLE_INHERIT
:
318 TRACE ("BFD_RELOC_VTABLE_INHERIT");
319 return &elf_howto_table
[R_386_GNU_VTINHERIT
- R_386_vt_offset
];
321 case BFD_RELOC_VTABLE_ENTRY
:
322 TRACE ("BFD_RELOC_VTABLE_ENTRY");
323 return &elf_howto_table
[R_386_GNU_VTENTRY
- R_386_vt_offset
];
334 elf_i386_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
336 Elf_Internal_Rela
*dst
)
338 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
341 if ((indx
= r_type
) >= R_386_standard
342 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
343 >= R_386_ext
- R_386_standard
)
344 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
345 >= R_386_tls
- R_386_ext
)
346 && ((indx
= r_type
- R_386_vt_offset
) - R_386_tls
347 >= R_386_vt
- R_386_tls
))
349 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
353 cache_ptr
->howto
= &elf_howto_table
[indx
];
356 /* Return whether a symbol name implies a local label. The UnixWare
357 2.1 cc generates temporary symbols that start with .X, so we
358 recognize them here. FIXME: do other SVR4 compilers also use .X?.
359 If so, we should move the .X recognition into
360 _bfd_elf_is_local_label_name. */
363 elf_i386_is_local_label_name (bfd
*abfd
, const char *name
)
365 if (name
[0] == '.' && name
[1] == 'X')
368 return _bfd_elf_is_local_label_name (abfd
, name
);
371 /* Support for core dump NOTE sections. */
374 elf_i386_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
379 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
381 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
387 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 20);
390 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
394 size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
398 switch (note
->descsz
)
403 case 144: /* Linux/i386 */
405 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
408 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
418 /* Make a ".reg/999" section. */
419 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
420 size
, note
->descpos
+ offset
);
424 elf_i386_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
426 if (note
->namesz
== 8 && strcmp (note
->namedata
, "FreeBSD") == 0)
428 int pr_version
= bfd_get_32 (abfd
, note
->descdata
);
433 elf_tdata (abfd
)->core_program
434 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 8, 17);
435 elf_tdata (abfd
)->core_command
436 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 25, 81);
440 switch (note
->descsz
)
445 case 124: /* Linux/i386 elf_prpsinfo. */
446 elf_tdata (abfd
)->core_program
447 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
448 elf_tdata (abfd
)->core_command
449 = _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. */
457 char *command
= elf_tdata (abfd
)->core_command
;
458 int n
= strlen (command
);
460 if (0 < n
&& command
[n
- 1] == ' ')
461 command
[n
- 1] = '\0';
467 /* Functions for the i386 ELF linker.
469 In order to gain some understanding of code in this file without
470 knowing all the intricate details of the linker, note the
473 Functions named elf_i386_* are called by external routines, other
474 functions are only called locally. elf_i386_* functions appear
475 in this file more or less in the order in which they are called
476 from external routines. eg. elf_i386_check_relocs is called
477 early in the link process, elf_i386_finish_dynamic_sections is
478 one of the last functions. */
481 /* The name of the dynamic interpreter. This is put in the .interp
484 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
486 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
487 copying dynamic variables from a shared lib into an app's dynbss
488 section, and instead use a dynamic relocation to point into the
490 #define ELIMINATE_COPY_RELOCS 1
492 /* The size in bytes of an entry in the procedure linkage table. */
494 #define PLT_ENTRY_SIZE 16
496 /* The first entry in an absolute procedure linkage table looks like
497 this. See the SVR4 ABI i386 supplement to see how this works.
498 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
500 static const bfd_byte elf_i386_plt0_entry
[12] =
502 0xff, 0x35, /* pushl contents of address */
503 0, 0, 0, 0, /* replaced with address of .got + 4. */
504 0xff, 0x25, /* jmp indirect */
505 0, 0, 0, 0 /* replaced with address of .got + 8. */
508 /* Subsequent entries in an absolute procedure linkage table look like
511 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
513 0xff, 0x25, /* jmp indirect */
514 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
515 0x68, /* pushl immediate */
516 0, 0, 0, 0, /* replaced with offset into relocation table. */
517 0xe9, /* jmp relative */
518 0, 0, 0, 0 /* replaced with offset to start of .plt. */
521 /* The first entry in a PIC procedure linkage table look like this.
522 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
524 static const bfd_byte elf_i386_pic_plt0_entry
[12] =
526 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
527 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
530 /* Subsequent entries in a PIC procedure linkage table look like this. */
532 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
534 0xff, 0xa3, /* jmp *offset(%ebx) */
535 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
536 0x68, /* pushl immediate */
537 0, 0, 0, 0, /* replaced with offset into relocation table. */
538 0xe9, /* jmp relative */
539 0, 0, 0, 0 /* replaced with offset to start of .plt. */
542 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
543 for the PLTResolve stub and then for each PLT entry. */
544 #define PLTRESOLVE_RELOCS_SHLIB 0
545 #define PLTRESOLVE_RELOCS 2
546 #define PLT_NON_JUMP_SLOT_RELOCS 2
548 /* The i386 linker needs to keep track of the number of relocs that it
549 decides to copy as dynamic relocs in check_relocs for each symbol.
550 This is so that it can later discard them if they are found to be
551 unnecessary. We store the information in a field extending the
552 regular ELF linker hash table. */
554 struct elf_i386_dyn_relocs
556 struct elf_i386_dyn_relocs
*next
;
558 /* The input section of the reloc. */
561 /* Total number of relocs copied for the input section. */
564 /* Number of pc-relative relocs copied for the input section. */
565 bfd_size_type pc_count
;
568 /* i386 ELF linker hash entry. */
570 struct elf_i386_link_hash_entry
572 struct elf_link_hash_entry elf
;
574 /* Track dynamic relocs copied for this symbol. */
575 struct elf_i386_dyn_relocs
*dyn_relocs
;
577 #define GOT_UNKNOWN 0
581 #define GOT_TLS_IE_POS 5
582 #define GOT_TLS_IE_NEG 6
583 #define GOT_TLS_IE_BOTH 7
584 #define GOT_TLS_GDESC 8
585 #define GOT_TLS_GD_BOTH_P(type) \
586 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
587 #define GOT_TLS_GD_P(type) \
588 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
589 #define GOT_TLS_GDESC_P(type) \
590 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
591 #define GOT_TLS_GD_ANY_P(type) \
592 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
593 unsigned char tls_type
;
595 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
596 starting at the end of the jump table. */
600 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
602 struct elf_i386_obj_tdata
604 struct elf_obj_tdata root
;
606 /* tls_type for each local got entry. */
607 char *local_got_tls_type
;
609 /* GOTPLT entries for TLS descriptors. */
610 bfd_vma
*local_tlsdesc_gotent
;
613 #define elf_i386_tdata(abfd) \
614 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
616 #define elf_i386_local_got_tls_type(abfd) \
617 (elf_i386_tdata (abfd)->local_got_tls_type)
619 #define elf_i386_local_tlsdesc_gotent(abfd) \
620 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
623 elf_i386_mkobject (bfd
*abfd
)
625 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
626 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
627 if (abfd
->tdata
.any
== NULL
)
632 /* i386 ELF linker hash table. */
634 struct elf_i386_link_hash_table
636 struct elf_link_hash_table elf
;
638 /* Short-cuts to get to dynamic linker sections. */
647 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
650 /* Short-cuts to frequently used symbols for VxWorks targets. */
651 struct elf_link_hash_entry
*hgot
, *hplt
;
653 /* True if the target system is VxWorks. */
656 /* Value used to fill the last word of the first plt entry. */
657 bfd_byte plt0_pad_byte
;
660 bfd_signed_vma refcount
;
664 /* The amount of space used by the reserved portion of the sgotplt
665 section, plus whatever space is used by the jump slots. */
666 bfd_vma sgotplt_jump_table_size
;
668 /* Small local sym to section mapping cache. */
669 struct sym_sec_cache sym_sec
;
672 /* Get the i386 ELF linker hash table from a link_info structure. */
674 #define elf_i386_hash_table(p) \
675 ((struct elf_i386_link_hash_table *) ((p)->hash))
677 #define elf_i386_compute_jump_table_size(htab) \
678 ((htab)->srelplt->reloc_count * 4)
680 /* Create an entry in an i386 ELF linker hash table. */
682 static struct bfd_hash_entry
*
683 link_hash_newfunc (struct bfd_hash_entry
*entry
,
684 struct bfd_hash_table
*table
,
687 /* Allocate the structure if it has not already been allocated by a
691 entry
= bfd_hash_allocate (table
,
692 sizeof (struct elf_i386_link_hash_entry
));
697 /* Call the allocation method of the superclass. */
698 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
701 struct elf_i386_link_hash_entry
*eh
;
703 eh
= (struct elf_i386_link_hash_entry
*) entry
;
704 eh
->dyn_relocs
= NULL
;
705 eh
->tls_type
= GOT_UNKNOWN
;
706 eh
->tlsdesc_got
= (bfd_vma
) -1;
712 /* Create an i386 ELF linker hash table. */
714 static struct bfd_link_hash_table
*
715 elf_i386_link_hash_table_create (bfd
*abfd
)
717 struct elf_i386_link_hash_table
*ret
;
718 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
720 ret
= bfd_malloc (amt
);
724 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
737 ret
->tls_ldm_got
.refcount
= 0;
738 ret
->sgotplt_jump_table_size
= 0;
739 ret
->sym_sec
.abfd
= NULL
;
741 ret
->srelplt2
= NULL
;
744 ret
->plt0_pad_byte
= 0;
746 return &ret
->elf
.root
;
749 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
750 shortcuts to them in our hash table. */
753 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
755 struct elf_i386_link_hash_table
*htab
;
757 if (! _bfd_elf_create_got_section (dynobj
, info
))
760 htab
= elf_i386_hash_table (info
);
761 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
762 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
763 if (!htab
->sgot
|| !htab
->sgotplt
)
766 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rel.got",
767 (SEC_ALLOC
| SEC_LOAD
772 if (htab
->srelgot
== NULL
773 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
778 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
779 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
783 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
785 struct elf_i386_link_hash_table
*htab
;
788 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
790 htab
= elf_i386_hash_table (info
);
791 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
794 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
797 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
798 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
799 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
801 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
803 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
804 || (!info
->shared
&& !htab
->srelbss
))
807 if (htab
->is_vxworks
&& !info
->shared
)
809 s
= bfd_make_section (dynobj
, ".rel.plt.unloaded");
810 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_READONLY
811 | SEC_LINKER_CREATED
);
813 || ! bfd_set_section_flags (dynobj
, s
, flags
)
814 || ! bfd_set_section_alignment (dynobj
, s
, bed
->s
->log_file_align
))
822 /* Copy the extra info we tack onto an elf_link_hash_entry. */
825 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
826 struct elf_link_hash_entry
*dir
,
827 struct elf_link_hash_entry
*ind
)
829 struct elf_i386_link_hash_entry
*edir
, *eind
;
831 edir
= (struct elf_i386_link_hash_entry
*) dir
;
832 eind
= (struct elf_i386_link_hash_entry
*) ind
;
834 if (eind
->dyn_relocs
!= NULL
)
836 if (edir
->dyn_relocs
!= NULL
)
838 struct elf_i386_dyn_relocs
**pp
;
839 struct elf_i386_dyn_relocs
*p
;
841 /* Add reloc counts against the indirect sym to the direct sym
842 list. Merge any entries against the same section. */
843 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
845 struct elf_i386_dyn_relocs
*q
;
847 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
848 if (q
->sec
== p
->sec
)
850 q
->pc_count
+= p
->pc_count
;
851 q
->count
+= p
->count
;
858 *pp
= edir
->dyn_relocs
;
861 edir
->dyn_relocs
= eind
->dyn_relocs
;
862 eind
->dyn_relocs
= NULL
;
865 if (ind
->root
.type
== bfd_link_hash_indirect
866 && dir
->got
.refcount
<= 0)
868 edir
->tls_type
= eind
->tls_type
;
869 eind
->tls_type
= GOT_UNKNOWN
;
872 if (ELIMINATE_COPY_RELOCS
873 && ind
->root
.type
!= bfd_link_hash_indirect
874 && dir
->dynamic_adjusted
)
876 /* If called to transfer flags for a weakdef during processing
877 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
878 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
879 dir
->ref_dynamic
|= ind
->ref_dynamic
;
880 dir
->ref_regular
|= ind
->ref_regular
;
881 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
882 dir
->needs_plt
|= ind
->needs_plt
;
883 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
886 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
890 elf_i386_tls_transition (struct bfd_link_info
*info
, int r_type
, int is_local
)
898 case R_386_TLS_GOTDESC
:
899 case R_386_TLS_DESC_CALL
:
900 case R_386_TLS_IE_32
:
902 return R_386_TLS_LE_32
;
903 return R_386_TLS_IE_32
;
905 case R_386_TLS_GOTIE
:
907 return R_386_TLS_LE_32
;
910 return R_386_TLS_LE_32
;
916 /* Look through the relocs for a section during the first phase, and
917 calculate needed space in the global offset table, procedure linkage
918 table, and dynamic reloc sections. */
921 elf_i386_check_relocs (bfd
*abfd
,
922 struct bfd_link_info
*info
,
924 const Elf_Internal_Rela
*relocs
)
926 struct elf_i386_link_hash_table
*htab
;
927 Elf_Internal_Shdr
*symtab_hdr
;
928 struct elf_link_hash_entry
**sym_hashes
;
929 const Elf_Internal_Rela
*rel
;
930 const Elf_Internal_Rela
*rel_end
;
933 if (info
->relocatable
)
936 htab
= elf_i386_hash_table (info
);
937 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
938 sym_hashes
= elf_sym_hashes (abfd
);
942 rel_end
= relocs
+ sec
->reloc_count
;
943 for (rel
= relocs
; rel
< rel_end
; rel
++)
946 unsigned long r_symndx
;
947 struct elf_link_hash_entry
*h
;
949 r_symndx
= ELF32_R_SYM (rel
->r_info
);
950 r_type
= ELF32_R_TYPE (rel
->r_info
);
952 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
954 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
960 if (r_symndx
< symtab_hdr
->sh_info
)
964 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
965 while (h
->root
.type
== bfd_link_hash_indirect
966 || h
->root
.type
== bfd_link_hash_warning
)
967 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
970 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
975 htab
->tls_ldm_got
.refcount
+= 1;
979 /* This symbol requires a procedure linkage table entry. We
980 actually build the entry in adjust_dynamic_symbol,
981 because this might be a case of linking PIC code which is
982 never referenced by a dynamic object, in which case we
983 don't need to generate a procedure linkage table entry
986 /* If this is a local symbol, we resolve it directly without
987 creating a procedure linkage table entry. */
992 h
->plt
.refcount
+= 1;
995 case R_386_TLS_IE_32
:
997 case R_386_TLS_GOTIE
:
999 info
->flags
|= DF_STATIC_TLS
;
1004 case R_386_TLS_GOTDESC
:
1005 case R_386_TLS_DESC_CALL
:
1006 /* This symbol requires a global offset table entry. */
1008 int tls_type
, old_tls_type
;
1013 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1014 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1015 case R_386_TLS_GOTDESC
:
1016 case R_386_TLS_DESC_CALL
:
1017 tls_type
= GOT_TLS_GDESC
; break;
1018 case R_386_TLS_IE_32
:
1019 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1020 tls_type
= GOT_TLS_IE_NEG
;
1022 /* If this is a GD->IE transition, we may use either of
1023 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1024 tls_type
= GOT_TLS_IE
;
1027 case R_386_TLS_GOTIE
:
1028 tls_type
= GOT_TLS_IE_POS
; break;
1033 h
->got
.refcount
+= 1;
1034 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1038 bfd_signed_vma
*local_got_refcounts
;
1040 /* This is a global offset table entry for a local symbol. */
1041 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1042 if (local_got_refcounts
== NULL
)
1046 size
= symtab_hdr
->sh_info
;
1047 size
*= (sizeof (bfd_signed_vma
)
1048 + sizeof (bfd_vma
) + sizeof(char));
1049 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1050 if (local_got_refcounts
== NULL
)
1052 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1053 elf_i386_local_tlsdesc_gotent (abfd
)
1054 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1055 elf_i386_local_got_tls_type (abfd
)
1056 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1058 local_got_refcounts
[r_symndx
] += 1;
1059 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1062 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1063 tls_type
|= old_tls_type
;
1064 /* If a TLS symbol is accessed using IE at least once,
1065 there is no point to use dynamic model for it. */
1066 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1067 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1068 || (tls_type
& GOT_TLS_IE
) == 0))
1070 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1071 tls_type
= old_tls_type
;
1072 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1073 && GOT_TLS_GD_ANY_P (tls_type
))
1074 tls_type
|= old_tls_type
;
1077 (*_bfd_error_handler
)
1078 (_("%B: `%s' accessed both as normal and "
1079 "thread local symbol"),
1081 h
? h
->root
.root
.string
: "<local>");
1086 if (old_tls_type
!= tls_type
)
1089 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1091 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1099 if (htab
->sgot
== NULL
)
1101 if (htab
->elf
.dynobj
== NULL
)
1102 htab
->elf
.dynobj
= abfd
;
1103 if (!create_got_section (htab
->elf
.dynobj
, info
))
1106 if (r_type
!= R_386_TLS_IE
)
1110 case R_386_TLS_LE_32
:
1114 info
->flags
|= DF_STATIC_TLS
;
1119 if (h
!= NULL
&& !info
->shared
)
1121 /* If this reloc is in a read-only section, we might
1122 need a copy reloc. We can't check reliably at this
1123 stage whether the section is read-only, as input
1124 sections have not yet been mapped to output sections.
1125 Tentatively set the flag for now, and correct in
1126 adjust_dynamic_symbol. */
1129 /* We may need a .plt entry if the function this reloc
1130 refers to is in a shared lib. */
1131 h
->plt
.refcount
+= 1;
1132 if (r_type
!= R_386_PC32
)
1133 h
->pointer_equality_needed
= 1;
1136 /* If we are creating a shared library, and this is a reloc
1137 against a global symbol, or a non PC relative reloc
1138 against a local symbol, then we need to copy the reloc
1139 into the shared library. However, if we are linking with
1140 -Bsymbolic, we do not need to copy a reloc against a
1141 global symbol which is defined in an object we are
1142 including in the link (i.e., DEF_REGULAR is set). At
1143 this point we have not seen all the input files, so it is
1144 possible that DEF_REGULAR is not set now but will be set
1145 later (it is never cleared). In case of a weak definition,
1146 DEF_REGULAR may be cleared later by a strong definition in
1147 a shared library. We account for that possibility below by
1148 storing information in the relocs_copied field of the hash
1149 table entry. A similar situation occurs when creating
1150 shared libraries and symbol visibility changes render the
1153 If on the other hand, we are creating an executable, we
1154 may need to keep relocations for symbols satisfied by a
1155 dynamic library if we manage to avoid copy relocs for the
1158 && (sec
->flags
& SEC_ALLOC
) != 0
1159 && (r_type
!= R_386_PC32
1161 && (! info
->symbolic
1162 || h
->root
.type
== bfd_link_hash_defweak
1163 || !h
->def_regular
))))
1164 || (ELIMINATE_COPY_RELOCS
1166 && (sec
->flags
& SEC_ALLOC
) != 0
1168 && (h
->root
.type
== bfd_link_hash_defweak
1169 || !h
->def_regular
)))
1171 struct elf_i386_dyn_relocs
*p
;
1172 struct elf_i386_dyn_relocs
**head
;
1174 /* We must copy these reloc types into the output file.
1175 Create a reloc section in dynobj and make room for
1181 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1182 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1184 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1188 if (strncmp (name
, ".rel", 4) != 0
1189 || strcmp (bfd_get_section_name (abfd
, sec
),
1192 (*_bfd_error_handler
)
1193 (_("%B: bad relocation section name `%s\'"),
1197 if (htab
->elf
.dynobj
== NULL
)
1198 htab
->elf
.dynobj
= abfd
;
1200 dynobj
= htab
->elf
.dynobj
;
1201 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1206 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1207 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1208 if ((sec
->flags
& SEC_ALLOC
) != 0)
1209 flags
|= SEC_ALLOC
| SEC_LOAD
;
1210 sreloc
= bfd_make_section_with_flags (dynobj
,
1214 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1217 elf_section_data (sec
)->sreloc
= sreloc
;
1220 /* If this is a global symbol, we count the number of
1221 relocations we need for this symbol. */
1224 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1229 /* Track dynamic relocs needed for local syms too.
1230 We really need local syms available to do this
1234 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1239 vpp
= &elf_section_data (s
)->local_dynrel
;
1240 head
= (struct elf_i386_dyn_relocs
**)vpp
;
1244 if (p
== NULL
|| p
->sec
!= sec
)
1246 bfd_size_type amt
= sizeof *p
;
1247 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1258 if (r_type
== R_386_PC32
)
1263 /* This relocation describes the C++ object vtable hierarchy.
1264 Reconstruct it for later use during GC. */
1265 case R_386_GNU_VTINHERIT
:
1266 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1270 /* This relocation describes which C++ vtable entries are actually
1271 used. Record for later use during GC. */
1272 case R_386_GNU_VTENTRY
:
1273 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1285 /* Return the section that should be marked against GC for a given
1289 elf_i386_gc_mark_hook (asection
*sec
,
1290 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1291 Elf_Internal_Rela
*rel
,
1292 struct elf_link_hash_entry
*h
,
1293 Elf_Internal_Sym
*sym
)
1297 switch (ELF32_R_TYPE (rel
->r_info
))
1299 case R_386_GNU_VTINHERIT
:
1300 case R_386_GNU_VTENTRY
:
1304 switch (h
->root
.type
)
1306 case bfd_link_hash_defined
:
1307 case bfd_link_hash_defweak
:
1308 return h
->root
.u
.def
.section
;
1310 case bfd_link_hash_common
:
1311 return h
->root
.u
.c
.p
->section
;
1319 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1324 /* Update the got entry reference counts for the section being removed. */
1327 elf_i386_gc_sweep_hook (bfd
*abfd
,
1328 struct bfd_link_info
*info
,
1330 const Elf_Internal_Rela
*relocs
)
1332 Elf_Internal_Shdr
*symtab_hdr
;
1333 struct elf_link_hash_entry
**sym_hashes
;
1334 bfd_signed_vma
*local_got_refcounts
;
1335 const Elf_Internal_Rela
*rel
, *relend
;
1337 elf_section_data (sec
)->local_dynrel
= NULL
;
1339 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1340 sym_hashes
= elf_sym_hashes (abfd
);
1341 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1343 relend
= relocs
+ sec
->reloc_count
;
1344 for (rel
= relocs
; rel
< relend
; rel
++)
1346 unsigned long r_symndx
;
1347 unsigned int r_type
;
1348 struct elf_link_hash_entry
*h
= NULL
;
1350 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1351 if (r_symndx
>= symtab_hdr
->sh_info
)
1353 struct elf_i386_link_hash_entry
*eh
;
1354 struct elf_i386_dyn_relocs
**pp
;
1355 struct elf_i386_dyn_relocs
*p
;
1357 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1358 while (h
->root
.type
== bfd_link_hash_indirect
1359 || h
->root
.type
== bfd_link_hash_warning
)
1360 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1361 eh
= (struct elf_i386_link_hash_entry
*) h
;
1363 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1366 /* Everything must go for SEC. */
1372 r_type
= ELF32_R_TYPE (rel
->r_info
);
1373 r_type
= elf_i386_tls_transition (info
, r_type
, h
!= NULL
);
1377 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1378 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1382 case R_386_TLS_GOTDESC
:
1383 case R_386_TLS_DESC_CALL
:
1384 case R_386_TLS_IE_32
:
1386 case R_386_TLS_GOTIE
:
1390 if (h
->got
.refcount
> 0)
1391 h
->got
.refcount
-= 1;
1393 else if (local_got_refcounts
!= NULL
)
1395 if (local_got_refcounts
[r_symndx
] > 0)
1396 local_got_refcounts
[r_symndx
] -= 1;
1409 if (h
->plt
.refcount
> 0)
1410 h
->plt
.refcount
-= 1;
1422 /* Adjust a symbol defined by a dynamic object and referenced by a
1423 regular object. The current definition is in some section of the
1424 dynamic object, but we're not including those sections. We have to
1425 change the definition to something the rest of the link can
1429 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1430 struct elf_link_hash_entry
*h
)
1432 struct elf_i386_link_hash_table
*htab
;
1434 unsigned int power_of_two
;
1436 /* If this is a function, put it in the procedure linkage table. We
1437 will fill in the contents of the procedure linkage table later,
1438 when we know the address of the .got section. */
1439 if (h
->type
== STT_FUNC
1442 if (h
->plt
.refcount
<= 0
1443 || SYMBOL_CALLS_LOCAL (info
, h
)
1444 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1445 && h
->root
.type
== bfd_link_hash_undefweak
))
1447 /* This case can occur if we saw a PLT32 reloc in an input
1448 file, but the symbol was never referred to by a dynamic
1449 object, or if all references were garbage collected. In
1450 such a case, we don't actually need to build a procedure
1451 linkage table, and we can just do a PC32 reloc instead. */
1452 h
->plt
.offset
= (bfd_vma
) -1;
1459 /* It's possible that we incorrectly decided a .plt reloc was
1460 needed for an R_386_PC32 reloc to a non-function sym in
1461 check_relocs. We can't decide accurately between function and
1462 non-function syms in check-relocs; Objects loaded later in
1463 the link may change h->type. So fix it now. */
1464 h
->plt
.offset
= (bfd_vma
) -1;
1466 /* If this is a weak symbol, and there is a real definition, the
1467 processor independent code will have arranged for us to see the
1468 real definition first, and we can just use the same value. */
1469 if (h
->u
.weakdef
!= NULL
)
1471 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1472 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1473 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1474 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1475 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1476 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1480 /* This is a reference to a symbol defined by a dynamic object which
1481 is not a function. */
1483 /* If we are creating a shared library, we must presume that the
1484 only references to the symbol are via the global offset table.
1485 For such cases we need not do anything here; the relocations will
1486 be handled correctly by relocate_section. */
1490 /* If there are no references to this symbol that do not use the
1491 GOT, we don't need to generate a copy reloc. */
1492 if (!h
->non_got_ref
)
1495 /* If -z nocopyreloc was given, we won't generate them either. */
1496 if (info
->nocopyreloc
)
1502 htab
= elf_i386_hash_table (info
);
1504 /* If there aren't any dynamic relocs in read-only sections, then
1505 we can keep the dynamic relocs and avoid the copy reloc. This
1506 doesn't work on VxWorks, where we can not have dynamic relocations
1507 (other than copy and jump slot relocations) in an executable. */
1508 if (ELIMINATE_COPY_RELOCS
&& !htab
->is_vxworks
)
1510 struct elf_i386_link_hash_entry
* eh
;
1511 struct elf_i386_dyn_relocs
*p
;
1513 eh
= (struct elf_i386_link_hash_entry
*) h
;
1514 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1516 s
= p
->sec
->output_section
;
1517 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1530 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1531 h
->root
.root
.string
);
1535 /* We must allocate the symbol in our .dynbss section, which will
1536 become part of the .bss section of the executable. There will be
1537 an entry for this symbol in the .dynsym section. The dynamic
1538 object will contain position independent code, so all references
1539 from the dynamic object to this symbol will go through the global
1540 offset table. The dynamic linker will use the .dynsym entry to
1541 determine the address it must put in the global offset table, so
1542 both the dynamic object and the regular object will refer to the
1543 same memory location for the variable. */
1545 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1546 copy the initial value out of the dynamic object and into the
1547 runtime process image. */
1548 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1550 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
1554 /* We need to figure out the alignment required for this symbol. I
1555 have no idea how ELF linkers handle this. */
1556 power_of_two
= bfd_log2 (h
->size
);
1557 if (power_of_two
> 3)
1560 /* Apply the required alignment. */
1562 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1563 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1565 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1569 /* Define the symbol as being at this point in the section. */
1570 h
->root
.u
.def
.section
= s
;
1571 h
->root
.u
.def
.value
= s
->size
;
1573 /* Increment the section size to make room for the symbol. */
1579 /* Allocate space in .plt, .got and associated reloc sections for
1583 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1585 struct bfd_link_info
*info
;
1586 struct elf_i386_link_hash_table
*htab
;
1587 struct elf_i386_link_hash_entry
*eh
;
1588 struct elf_i386_dyn_relocs
*p
;
1590 if (h
->root
.type
== bfd_link_hash_indirect
)
1593 if (h
->root
.type
== bfd_link_hash_warning
)
1594 /* When warning symbols are created, they **replace** the "real"
1595 entry in the hash table, thus we never get to see the real
1596 symbol in a hash traversal. So look at it now. */
1597 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1599 info
= (struct bfd_link_info
*) inf
;
1600 htab
= elf_i386_hash_table (info
);
1602 if (htab
->elf
.dynamic_sections_created
1603 && h
->plt
.refcount
> 0)
1605 /* Make sure this symbol is output as a dynamic symbol.
1606 Undefined weak syms won't yet be marked as dynamic. */
1607 if (h
->dynindx
== -1
1608 && !h
->forced_local
)
1610 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1615 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1617 asection
*s
= htab
->splt
;
1619 /* If this is the first .plt entry, make room for the special
1622 s
->size
+= PLT_ENTRY_SIZE
;
1624 h
->plt
.offset
= s
->size
;
1626 /* If this symbol is not defined in a regular file, and we are
1627 not generating a shared library, then set the symbol to this
1628 location in the .plt. This is required to make function
1629 pointers compare as equal between the normal executable and
1630 the shared library. */
1634 h
->root
.u
.def
.section
= s
;
1635 h
->root
.u
.def
.value
= h
->plt
.offset
;
1638 /* Make room for this entry. */
1639 s
->size
+= PLT_ENTRY_SIZE
;
1641 /* We also need to make an entry in the .got.plt section, which
1642 will be placed in the .got section by the linker script. */
1643 htab
->sgotplt
->size
+= 4;
1645 /* We also need to make an entry in the .rel.plt section. */
1646 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1647 htab
->srelplt
->reloc_count
++;
1649 if (htab
->is_vxworks
&& !info
->shared
)
1651 /* VxWorks has a second set of relocations for each PLT entry
1652 in executables. They go in a separate relocation section,
1653 which is processed by the kernel loader. */
1655 /* There are two relocations for the initial PLT entry: an
1656 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1657 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1659 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
1660 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1662 /* There are two extra relocations for each subsequent PLT entry:
1663 an R_386_32 relocation for the GOT entry, and an R_386_32
1664 relocation for the PLT entry. */
1666 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1671 h
->plt
.offset
= (bfd_vma
) -1;
1677 h
->plt
.offset
= (bfd_vma
) -1;
1681 eh
= (struct elf_i386_link_hash_entry
*) h
;
1682 eh
->tlsdesc_got
= (bfd_vma
) -1;
1684 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1685 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1686 if (h
->got
.refcount
> 0
1689 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
1690 h
->got
.offset
= (bfd_vma
) -1;
1691 else if (h
->got
.refcount
> 0)
1695 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1697 /* Make sure this symbol is output as a dynamic symbol.
1698 Undefined weak syms won't yet be marked as dynamic. */
1699 if (h
->dynindx
== -1
1700 && !h
->forced_local
)
1702 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1707 if (GOT_TLS_GDESC_P (tls_type
))
1709 eh
->tlsdesc_got
= htab
->sgotplt
->size
1710 - elf_i386_compute_jump_table_size (htab
);
1711 htab
->sgotplt
->size
+= 8;
1712 h
->got
.offset
= (bfd_vma
) -2;
1714 if (! GOT_TLS_GDESC_P (tls_type
)
1715 || GOT_TLS_GD_P (tls_type
))
1717 h
->got
.offset
= s
->size
;
1719 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1720 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
1723 dyn
= htab
->elf
.dynamic_sections_created
;
1724 /* R_386_TLS_IE_32 needs one dynamic relocation,
1725 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1726 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1727 need two), R_386_TLS_GD needs one if local symbol and two if
1729 if (tls_type
== GOT_TLS_IE_BOTH
)
1730 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1731 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
1732 || (tls_type
& GOT_TLS_IE
))
1733 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1734 else if (GOT_TLS_GD_P (tls_type
))
1735 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1736 else if (! GOT_TLS_GDESC_P (tls_type
)
1737 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1738 || h
->root
.type
!= bfd_link_hash_undefweak
)
1740 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
1741 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1742 if (GOT_TLS_GDESC_P (tls_type
))
1743 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1746 h
->got
.offset
= (bfd_vma
) -1;
1748 if (eh
->dyn_relocs
== NULL
)
1751 /* In the shared -Bsymbolic case, discard space allocated for
1752 dynamic pc-relative relocs against symbols which turn out to be
1753 defined in regular objects. For the normal shared case, discard
1754 space for pc-relative relocs that have become local due to symbol
1755 visibility changes. */
1759 /* The only reloc that uses pc_count is R_386_PC32, which will
1760 appear on a call or on something like ".long foo - .". We
1761 want calls to protected symbols to resolve directly to the
1762 function rather than going via the plt. If people want
1763 function pointer comparisons to work as expected then they
1764 should avoid writing assembly like ".long foo - .". */
1765 if (SYMBOL_CALLS_LOCAL (info
, h
))
1767 struct elf_i386_dyn_relocs
**pp
;
1769 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1771 p
->count
-= p
->pc_count
;
1780 /* Also discard relocs on undefined weak syms with non-default
1782 if (eh
->dyn_relocs
!= NULL
1783 && h
->root
.type
== bfd_link_hash_undefweak
)
1785 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1786 eh
->dyn_relocs
= NULL
;
1788 /* Make sure undefined weak symbols are output as a dynamic
1790 else if (h
->dynindx
== -1
1791 && !h
->forced_local
)
1793 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1798 else if (ELIMINATE_COPY_RELOCS
)
1800 /* For the non-shared case, discard space for relocs against
1801 symbols which turn out to need copy relocs or are not
1807 || (htab
->elf
.dynamic_sections_created
1808 && (h
->root
.type
== bfd_link_hash_undefweak
1809 || h
->root
.type
== bfd_link_hash_undefined
))))
1811 /* Make sure this symbol is output as a dynamic symbol.
1812 Undefined weak syms won't yet be marked as dynamic. */
1813 if (h
->dynindx
== -1
1814 && !h
->forced_local
)
1816 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1820 /* If that succeeded, we know we'll be keeping all the
1822 if (h
->dynindx
!= -1)
1826 eh
->dyn_relocs
= NULL
;
1831 /* Finally, allocate space. */
1832 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1834 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1835 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1841 /* Find any dynamic relocs that apply to read-only sections. */
1844 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1846 struct elf_i386_link_hash_entry
*eh
;
1847 struct elf_i386_dyn_relocs
*p
;
1849 if (h
->root
.type
== bfd_link_hash_warning
)
1850 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1852 eh
= (struct elf_i386_link_hash_entry
*) h
;
1853 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1855 asection
*s
= p
->sec
->output_section
;
1857 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1859 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1861 info
->flags
|= DF_TEXTREL
;
1863 /* Not an error, just cut short the traversal. */
1870 /* Set the sizes of the dynamic sections. */
1873 elf_i386_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1874 struct bfd_link_info
*info
)
1876 struct elf_i386_link_hash_table
*htab
;
1882 htab
= elf_i386_hash_table (info
);
1883 dynobj
= htab
->elf
.dynobj
;
1887 if (htab
->elf
.dynamic_sections_created
)
1889 /* Set the contents of the .interp section to the interpreter. */
1890 if (info
->executable
)
1892 s
= bfd_get_section_by_name (dynobj
, ".interp");
1895 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1896 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1900 /* Set up .got offsets for local syms, and space for local dynamic
1902 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1904 bfd_signed_vma
*local_got
;
1905 bfd_signed_vma
*end_local_got
;
1906 char *local_tls_type
;
1907 bfd_vma
*local_tlsdesc_gotent
;
1908 bfd_size_type locsymcount
;
1909 Elf_Internal_Shdr
*symtab_hdr
;
1912 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1915 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1917 struct elf_i386_dyn_relocs
*p
;
1919 for (p
= ((struct elf_i386_dyn_relocs
*)
1920 elf_section_data (s
)->local_dynrel
);
1924 if (!bfd_is_abs_section (p
->sec
)
1925 && bfd_is_abs_section (p
->sec
->output_section
))
1927 /* Input section has been discarded, either because
1928 it is a copy of a linkonce section or due to
1929 linker script /DISCARD/, so we'll be discarding
1932 else if (p
->count
!= 0)
1934 srel
= elf_section_data (p
->sec
)->sreloc
;
1935 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1936 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1937 info
->flags
|= DF_TEXTREL
;
1942 local_got
= elf_local_got_refcounts (ibfd
);
1946 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1947 locsymcount
= symtab_hdr
->sh_info
;
1948 end_local_got
= local_got
+ locsymcount
;
1949 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1950 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
1952 srel
= htab
->srelgot
;
1953 for (; local_got
< end_local_got
;
1954 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
1956 *local_tlsdesc_gotent
= (bfd_vma
) -1;
1959 if (GOT_TLS_GDESC_P (*local_tls_type
))
1961 *local_tlsdesc_gotent
= htab
->sgotplt
->size
1962 - elf_i386_compute_jump_table_size (htab
);
1963 htab
->sgotplt
->size
+= 8;
1964 *local_got
= (bfd_vma
) -2;
1966 if (! GOT_TLS_GDESC_P (*local_tls_type
)
1967 || GOT_TLS_GD_P (*local_tls_type
))
1969 *local_got
= s
->size
;
1971 if (GOT_TLS_GD_P (*local_tls_type
)
1972 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1976 || GOT_TLS_GD_ANY_P (*local_tls_type
)
1977 || (*local_tls_type
& GOT_TLS_IE
))
1979 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1980 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
1981 else if (GOT_TLS_GD_P (*local_tls_type
)
1982 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1983 srel
->size
+= sizeof (Elf32_External_Rel
);
1984 if (GOT_TLS_GDESC_P (*local_tls_type
))
1985 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1989 *local_got
= (bfd_vma
) -1;
1993 if (htab
->tls_ldm_got
.refcount
> 0)
1995 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1997 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
1998 htab
->sgot
->size
+= 8;
1999 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
2002 htab
->tls_ldm_got
.offset
= -1;
2004 if (htab
->is_vxworks
)
2006 /* Save the GOT and PLT symbols in the hash table for easy access.
2007 Mark them as having relocations; they might not, but we won't
2008 know for sure until we build the GOT in finish_dynamic_symbol. */
2010 htab
->hgot
= elf_link_hash_lookup (elf_hash_table (info
),
2011 "_GLOBAL_OFFSET_TABLE_",
2012 FALSE
, FALSE
, FALSE
);
2014 htab
->hgot
->indx
= -2;
2015 htab
->hplt
= elf_link_hash_lookup (elf_hash_table (info
),
2016 "_PROCEDURE_LINKAGE_TABLE_",
2017 FALSE
, FALSE
, FALSE
);
2019 htab
->hplt
->indx
= -2;
2021 if (htab
->is_vxworks
&& htab
->hplt
&& htab
->splt
->flags
& SEC_CODE
)
2022 htab
->hplt
->type
= STT_FUNC
;
2025 /* Allocate global sym .plt and .got entries, and space for global
2026 sym dynamic relocs. */
2027 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2029 /* For every jump slot reserved in the sgotplt, reloc_count is
2030 incremented. However, when we reserve space for TLS descriptors,
2031 it's not incremented, so in order to compute the space reserved
2032 for them, it suffices to multiply the reloc count by the jump
2035 htab
->sgotplt_jump_table_size
= htab
->srelplt
->reloc_count
* 4;
2037 /* We now have determined the sizes of the various dynamic sections.
2038 Allocate memory for them. */
2040 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2042 bfd_boolean strip_section
= TRUE
;
2044 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2049 || s
== htab
->sgotplt
2050 || s
== htab
->sdynbss
)
2052 /* Strip this section if we don't need it; see the
2054 /* We'd like to strip these sections if they aren't needed, but if
2055 we've exported dynamic symbols from them we must leave them.
2056 It's too late to tell BFD to get rid of the symbols. */
2058 if (htab
->hplt
!= NULL
)
2059 strip_section
= FALSE
;
2061 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
2063 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
2066 /* We use the reloc_count field as a counter if we need
2067 to copy relocs into the output file. */
2068 if (s
!= htab
->srelplt
)
2073 /* It's not one of our sections, so don't allocate space. */
2079 /* If we don't need this section, strip it from the
2080 output file. This is mostly to handle .rel.bss and
2081 .rel.plt. We must create both sections in
2082 create_dynamic_sections, because they must be created
2083 before the linker maps input sections to output
2084 sections. The linker does that before
2085 adjust_dynamic_symbol is called, and it is that
2086 function which decides whether anything needs to go
2087 into these sections. */
2089 s
->flags
|= SEC_EXCLUDE
;
2093 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2096 /* Allocate memory for the section contents. We use bfd_zalloc
2097 here in case unused entries are not reclaimed before the
2098 section's contents are written out. This should not happen,
2099 but this way if it does, we get a R_386_NONE reloc instead
2101 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2102 if (s
->contents
== NULL
)
2106 if (htab
->elf
.dynamic_sections_created
)
2108 /* Add some entries to the .dynamic section. We fill in the
2109 values later, in elf_i386_finish_dynamic_sections, but we
2110 must add the entries now so that we get the correct size for
2111 the .dynamic section. The DT_DEBUG entry is filled in by the
2112 dynamic linker and used by the debugger. */
2113 #define add_dynamic_entry(TAG, VAL) \
2114 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2116 if (info
->executable
)
2118 if (!add_dynamic_entry (DT_DEBUG
, 0))
2122 if (htab
->splt
->size
!= 0)
2124 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2125 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2126 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2127 || !add_dynamic_entry (DT_JMPREL
, 0))
2133 if (!add_dynamic_entry (DT_REL
, 0)
2134 || !add_dynamic_entry (DT_RELSZ
, 0)
2135 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2138 /* If any dynamic relocs apply to a read-only section,
2139 then we need a DT_TEXTREL entry. */
2140 if ((info
->flags
& DF_TEXTREL
) == 0)
2141 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2144 if ((info
->flags
& DF_TEXTREL
) != 0)
2146 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2151 #undef add_dynamic_entry
2157 elf_i386_always_size_sections (bfd
*output_bfd
,
2158 struct bfd_link_info
*info
)
2160 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2164 struct elf_link_hash_entry
*tlsbase
;
2166 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2167 "_TLS_MODULE_BASE_",
2168 FALSE
, FALSE
, FALSE
);
2170 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2172 struct bfd_link_hash_entry
*bh
= NULL
;
2173 const struct elf_backend_data
*bed
2174 = get_elf_backend_data (output_bfd
);
2176 if (!(_bfd_generic_link_add_one_symbol
2177 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2178 tls_sec
, 0, NULL
, FALSE
,
2179 bed
->collect
, &bh
)))
2181 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2182 tlsbase
->def_regular
= 1;
2183 tlsbase
->other
= STV_HIDDEN
;
2184 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2191 /* Set the correct type for an x86 ELF section. We do this by the
2192 section name, which is a hack, but ought to work. */
2195 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2196 Elf_Internal_Shdr
*hdr
,
2199 register const char *name
;
2201 name
= bfd_get_section_name (abfd
, sec
);
2203 /* This is an ugly, but unfortunately necessary hack that is
2204 needed when producing EFI binaries on x86. It tells
2205 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2206 containing ELF relocation info. We need this hack in order to
2207 be able to generate ELF binaries that can be translated into
2208 EFI applications (which are essentially COFF objects). Those
2209 files contain a COFF ".reloc" section inside an ELFNN object,
2210 which would normally cause BFD to segfault because it would
2211 attempt to interpret this section as containing relocation
2212 entries for section "oc". With this hack enabled, ".reloc"
2213 will be treated as a normal data section, which will avoid the
2214 segfault. However, you won't be able to create an ELFNN binary
2215 with a section named "oc" that needs relocations, but that's
2216 the kind of ugly side-effects you get when detecting section
2217 types based on their names... In practice, this limitation is
2218 unlikely to bite. */
2219 if (strcmp (name
, ".reloc") == 0)
2220 hdr
->sh_type
= SHT_PROGBITS
;
2225 /* Return the base VMA address which should be subtracted from real addresses
2226 when resolving @dtpoff relocation.
2227 This is PT_TLS segment p_vaddr. */
2230 dtpoff_base (struct bfd_link_info
*info
)
2232 /* If tls_sec is NULL, we should have signalled an error already. */
2233 if (elf_hash_table (info
)->tls_sec
== NULL
)
2235 return elf_hash_table (info
)->tls_sec
->vma
;
2238 /* Return the relocation value for @tpoff relocation
2239 if STT_TLS virtual address is ADDRESS. */
2242 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2244 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2246 /* If tls_sec is NULL, we should have signalled an error already. */
2247 if (htab
->tls_sec
== NULL
)
2249 return htab
->tls_size
+ htab
->tls_sec
->vma
- address
;
2252 /* Relocate an i386 ELF section. */
2255 elf_i386_relocate_section (bfd
*output_bfd
,
2256 struct bfd_link_info
*info
,
2258 asection
*input_section
,
2260 Elf_Internal_Rela
*relocs
,
2261 Elf_Internal_Sym
*local_syms
,
2262 asection
**local_sections
)
2264 struct elf_i386_link_hash_table
*htab
;
2265 Elf_Internal_Shdr
*symtab_hdr
;
2266 struct elf_link_hash_entry
**sym_hashes
;
2267 bfd_vma
*local_got_offsets
;
2268 bfd_vma
*local_tlsdesc_gotents
;
2269 Elf_Internal_Rela
*rel
;
2270 Elf_Internal_Rela
*relend
;
2272 htab
= elf_i386_hash_table (info
);
2273 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2274 sym_hashes
= elf_sym_hashes (input_bfd
);
2275 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2276 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2279 relend
= relocs
+ input_section
->reloc_count
;
2280 for (; rel
< relend
; rel
++)
2282 unsigned int r_type
;
2283 reloc_howto_type
*howto
;
2284 unsigned long r_symndx
;
2285 struct elf_link_hash_entry
*h
;
2286 Elf_Internal_Sym
*sym
;
2288 bfd_vma off
, offplt
;
2290 bfd_boolean unresolved_reloc
;
2291 bfd_reloc_status_type r
;
2295 r_type
= ELF32_R_TYPE (rel
->r_info
);
2296 if (r_type
== R_386_GNU_VTINHERIT
2297 || r_type
== R_386_GNU_VTENTRY
)
2300 if ((indx
= r_type
) >= R_386_standard
2301 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2302 >= R_386_ext
- R_386_standard
)
2303 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2304 >= R_386_tls
- R_386_ext
))
2306 (*_bfd_error_handler
)
2307 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2308 input_bfd
, input_section
, r_type
);
2309 bfd_set_error (bfd_error_bad_value
);
2312 howto
= elf_howto_table
+ indx
;
2314 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2316 if (info
->relocatable
)
2321 /* This is a relocatable link. We don't have to change
2322 anything, unless the reloc is against a section symbol,
2323 in which case we have to adjust according to where the
2324 section symbol winds up in the output section. */
2325 if (r_symndx
>= symtab_hdr
->sh_info
)
2328 sym
= local_syms
+ r_symndx
;
2329 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2332 sec
= local_sections
[r_symndx
];
2333 val
= sec
->output_offset
;
2337 where
= contents
+ rel
->r_offset
;
2338 switch (howto
->size
)
2340 /* FIXME: overflow checks. */
2342 val
+= bfd_get_8 (input_bfd
, where
);
2343 bfd_put_8 (input_bfd
, val
, where
);
2346 val
+= bfd_get_16 (input_bfd
, where
);
2347 bfd_put_16 (input_bfd
, val
, where
);
2350 val
+= bfd_get_32 (input_bfd
, where
);
2351 bfd_put_32 (input_bfd
, val
, where
);
2359 /* This is a final link. */
2363 unresolved_reloc
= FALSE
;
2364 if (r_symndx
< symtab_hdr
->sh_info
)
2366 sym
= local_syms
+ r_symndx
;
2367 sec
= local_sections
[r_symndx
];
2368 relocation
= (sec
->output_section
->vma
2369 + sec
->output_offset
2371 if ((sec
->flags
& SEC_MERGE
)
2372 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2376 bfd_byte
*where
= contents
+ rel
->r_offset
;
2378 switch (howto
->size
)
2381 addend
= bfd_get_8 (input_bfd
, where
);
2382 if (howto
->pc_relative
)
2384 addend
= (addend
^ 0x80) - 0x80;
2389 addend
= bfd_get_16 (input_bfd
, where
);
2390 if (howto
->pc_relative
)
2392 addend
= (addend
^ 0x8000) - 0x8000;
2397 addend
= bfd_get_32 (input_bfd
, where
);
2398 if (howto
->pc_relative
)
2400 addend
= (addend
^ 0x80000000) - 0x80000000;
2409 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2410 addend
-= relocation
;
2411 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2413 switch (howto
->size
)
2416 /* FIXME: overflow checks. */
2417 if (howto
->pc_relative
)
2419 bfd_put_8 (input_bfd
, addend
, where
);
2422 if (howto
->pc_relative
)
2424 bfd_put_16 (input_bfd
, addend
, where
);
2427 if (howto
->pc_relative
)
2429 bfd_put_32 (input_bfd
, addend
, where
);
2438 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2439 r_symndx
, symtab_hdr
, sym_hashes
,
2441 unresolved_reloc
, warned
);
2446 /* r_symndx will be zero only for relocs against symbols from
2447 removed linkonce sections, or sections discarded by a linker
2448 script. For these relocs, we just want the section contents
2449 zeroed. Avoid any special processing in the switch below. */
2450 r_type
= R_386_NONE
;
2453 if (howto
->pc_relative
)
2454 relocation
= (input_section
->output_section
->vma
2455 + input_section
->output_offset
2462 /* Relocation is to the entry for this symbol in the global
2464 if (htab
->sgot
== NULL
)
2471 off
= h
->got
.offset
;
2472 dyn
= htab
->elf
.dynamic_sections_created
;
2473 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2475 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2476 || (ELF_ST_VISIBILITY (h
->other
)
2477 && h
->root
.type
== bfd_link_hash_undefweak
))
2479 /* This is actually a static link, or it is a
2480 -Bsymbolic link and the symbol is defined
2481 locally, or the symbol was forced to be local
2482 because of a version file. We must initialize
2483 this entry in the global offset table. Since the
2484 offset must always be a multiple of 4, we use the
2485 least significant bit to record whether we have
2486 initialized it already.
2488 When doing a dynamic link, we create a .rel.got
2489 relocation entry to initialize the value. This
2490 is done in the finish_dynamic_symbol routine. */
2495 bfd_put_32 (output_bfd
, relocation
,
2496 htab
->sgot
->contents
+ off
);
2501 unresolved_reloc
= FALSE
;
2505 if (local_got_offsets
== NULL
)
2508 off
= local_got_offsets
[r_symndx
];
2510 /* The offset must always be a multiple of 4. We use
2511 the least significant bit to record whether we have
2512 already generated the necessary reloc. */
2517 bfd_put_32 (output_bfd
, relocation
,
2518 htab
->sgot
->contents
+ off
);
2523 Elf_Internal_Rela outrel
;
2530 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2531 + htab
->sgot
->output_offset
2533 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2535 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2536 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2539 local_got_offsets
[r_symndx
] |= 1;
2543 if (off
>= (bfd_vma
) -2)
2546 relocation
= htab
->sgot
->output_section
->vma
2547 + htab
->sgot
->output_offset
+ off
2548 - htab
->sgotplt
->output_section
->vma
2549 - htab
->sgotplt
->output_offset
;
2553 /* Relocation is relative to the start of the global offset
2556 /* Check to make sure it isn't a protected function symbol
2557 for shared library since it may not be local when used
2558 as function address. */
2560 && !info
->executable
2563 && h
->type
== STT_FUNC
2564 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
2566 (*_bfd_error_handler
)
2567 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2568 input_bfd
, h
->root
.root
.string
);
2569 bfd_set_error (bfd_error_bad_value
);
2573 /* Note that sgot is not involved in this
2574 calculation. We always want the start of .got.plt. If we
2575 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2576 permitted by the ABI, we might have to change this
2578 relocation
-= htab
->sgotplt
->output_section
->vma
2579 + htab
->sgotplt
->output_offset
;
2583 /* Use global offset table as symbol value. */
2584 relocation
= htab
->sgotplt
->output_section
->vma
2585 + htab
->sgotplt
->output_offset
;
2586 unresolved_reloc
= FALSE
;
2590 /* Relocation is to the entry for this symbol in the
2591 procedure linkage table. */
2593 /* Resolve a PLT32 reloc against a local symbol directly,
2594 without using the procedure linkage table. */
2598 if (h
->plt
.offset
== (bfd_vma
) -1
2599 || htab
->splt
== NULL
)
2601 /* We didn't make a PLT entry for this symbol. This
2602 happens when statically linking PIC code, or when
2603 using -Bsymbolic. */
2607 relocation
= (htab
->splt
->output_section
->vma
2608 + htab
->splt
->output_offset
2610 unresolved_reloc
= FALSE
;
2615 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2620 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2621 || h
->root
.type
!= bfd_link_hash_undefweak
)
2622 && (r_type
!= R_386_PC32
2623 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2624 || (ELIMINATE_COPY_RELOCS
2631 || h
->root
.type
== bfd_link_hash_undefweak
2632 || h
->root
.type
== bfd_link_hash_undefined
)))
2634 Elf_Internal_Rela outrel
;
2636 bfd_boolean skip
, relocate
;
2639 /* When generating a shared object, these relocations
2640 are copied into the output file to be resolved at run
2647 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2649 if (outrel
.r_offset
== (bfd_vma
) -1)
2651 else if (outrel
.r_offset
== (bfd_vma
) -2)
2652 skip
= TRUE
, relocate
= TRUE
;
2653 outrel
.r_offset
+= (input_section
->output_section
->vma
2654 + input_section
->output_offset
);
2657 memset (&outrel
, 0, sizeof outrel
);
2660 && (r_type
== R_386_PC32
2663 || !h
->def_regular
))
2664 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2667 /* This symbol is local, or marked to become local. */
2669 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2672 sreloc
= elf_section_data (input_section
)->sreloc
;
2676 loc
= sreloc
->contents
;
2677 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2678 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2680 /* If this reloc is against an external symbol, we do
2681 not want to fiddle with the addend. Otherwise, we
2682 need to include the symbol value so that it becomes
2683 an addend for the dynamic reloc. */
2692 Elf_Internal_Rela outrel
;
2696 outrel
.r_offset
= rel
->r_offset
2697 + input_section
->output_section
->vma
2698 + input_section
->output_offset
;
2699 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2700 sreloc
= elf_section_data (input_section
)->sreloc
;
2703 loc
= sreloc
->contents
;
2704 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2705 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2710 case R_386_TLS_GOTDESC
:
2711 case R_386_TLS_DESC_CALL
:
2712 case R_386_TLS_IE_32
:
2713 case R_386_TLS_GOTIE
:
2714 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2715 tls_type
= GOT_UNKNOWN
;
2716 if (h
== NULL
&& local_got_offsets
)
2717 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2720 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2721 if (!info
->shared
&& h
->dynindx
== -1 && (tls_type
& GOT_TLS_IE
))
2722 r_type
= R_386_TLS_LE_32
;
2724 if (tls_type
== GOT_TLS_IE
)
2725 tls_type
= GOT_TLS_IE_NEG
;
2726 if (r_type
== R_386_TLS_GD
2727 || r_type
== R_386_TLS_GOTDESC
2728 || r_type
== R_386_TLS_DESC_CALL
)
2730 if (tls_type
== GOT_TLS_IE_POS
)
2731 r_type
= R_386_TLS_GOTIE
;
2732 else if (tls_type
& GOT_TLS_IE
)
2733 r_type
= R_386_TLS_IE_32
;
2736 if (r_type
== R_386_TLS_LE_32
)
2738 BFD_ASSERT (! unresolved_reloc
);
2739 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2741 unsigned int val
, type
;
2744 /* GD->LE transition. */
2745 BFD_ASSERT (rel
->r_offset
>= 2);
2746 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2747 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2748 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
2749 BFD_ASSERT (bfd_get_8 (input_bfd
,
2750 contents
+ rel
->r_offset
+ 4)
2752 BFD_ASSERT (rel
+ 1 < relend
);
2753 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2754 roff
= rel
->r_offset
+ 5;
2755 val
= bfd_get_8 (input_bfd
,
2756 contents
+ rel
->r_offset
- 1);
2759 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2761 movl %gs:0, %eax; subl $foo@tpoff, %eax
2762 (6 byte form of subl). */
2763 BFD_ASSERT (rel
->r_offset
>= 3);
2764 BFD_ASSERT (bfd_get_8 (input_bfd
,
2765 contents
+ rel
->r_offset
- 3)
2767 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2768 memcpy (contents
+ rel
->r_offset
- 3,
2769 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2773 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2774 if (rel
->r_offset
+ 10 <= input_section
->size
2775 && bfd_get_8 (input_bfd
,
2776 contents
+ rel
->r_offset
+ 9) == 0x90)
2778 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2780 movl %gs:0, %eax; subl $foo@tpoff, %eax
2781 (6 byte form of subl). */
2782 memcpy (contents
+ rel
->r_offset
- 2,
2783 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2784 roff
= rel
->r_offset
+ 6;
2788 /* leal foo(%reg), %eax; call ___tls_get_addr
2790 movl %gs:0, %eax; subl $foo@tpoff, %eax
2791 (5 byte form of subl). */
2792 memcpy (contents
+ rel
->r_offset
- 2,
2793 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2796 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2798 /* Skip R_386_PLT32. */
2802 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
2804 /* GDesc -> LE transition.
2805 It's originally something like:
2806 leal x@tlsdesc(%ebx), %eax
2810 Registers other than %eax may be set up here. */
2812 unsigned int val
, type
;
2815 /* First, make sure it's a leal adding ebx to a
2816 32-bit offset into any register, although it's
2817 probably almost always going to be eax. */
2818 roff
= rel
->r_offset
;
2819 BFD_ASSERT (roff
>= 2);
2820 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
2821 BFD_ASSERT (type
== 0x8d);
2822 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
2823 BFD_ASSERT ((val
& 0xc7) == 0x83);
2824 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
2826 /* Now modify the instruction as appropriate. */
2827 /* aoliva FIXME: remove the above and xor the byte
2829 bfd_put_8 (output_bfd
, val
^ 0x86,
2830 contents
+ roff
- 1);
2831 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2835 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
2837 /* GDesc -> LE transition.
2843 unsigned int val
, type
;
2846 /* First, make sure it's a call *(%eax). */
2847 roff
= rel
->r_offset
;
2848 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
2849 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
2850 BFD_ASSERT (type
== 0xff);
2851 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
2852 BFD_ASSERT (val
== 0x10);
2854 /* Now modify the instruction as appropriate. */
2855 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
2856 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
2859 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
2861 unsigned int val
, type
;
2863 /* IE->LE transition:
2864 Originally it can be one of:
2872 BFD_ASSERT (rel
->r_offset
>= 1);
2873 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2874 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2877 /* movl foo, %eax. */
2878 bfd_put_8 (output_bfd
, 0xb8,
2879 contents
+ rel
->r_offset
- 1);
2883 BFD_ASSERT (rel
->r_offset
>= 2);
2884 type
= bfd_get_8 (input_bfd
,
2885 contents
+ rel
->r_offset
- 2);
2890 BFD_ASSERT ((val
& 0xc7) == 0x05);
2891 bfd_put_8 (output_bfd
, 0xc7,
2892 contents
+ rel
->r_offset
- 2);
2893 bfd_put_8 (output_bfd
,
2894 0xc0 | ((val
>> 3) & 7),
2895 contents
+ rel
->r_offset
- 1);
2899 BFD_ASSERT ((val
& 0xc7) == 0x05);
2900 bfd_put_8 (output_bfd
, 0x81,
2901 contents
+ rel
->r_offset
- 2);
2902 bfd_put_8 (output_bfd
,
2903 0xc0 | ((val
>> 3) & 7),
2904 contents
+ rel
->r_offset
- 1);
2911 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2912 contents
+ rel
->r_offset
);
2917 unsigned int val
, type
;
2919 /* {IE_32,GOTIE}->LE transition:
2920 Originally it can be one of:
2921 subl foo(%reg1), %reg2
2922 movl foo(%reg1), %reg2
2923 addl foo(%reg1), %reg2
2926 movl $foo, %reg2 (6 byte form)
2927 addl $foo, %reg2. */
2928 BFD_ASSERT (rel
->r_offset
>= 2);
2929 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2930 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2931 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2932 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2936 bfd_put_8 (output_bfd
, 0xc7,
2937 contents
+ rel
->r_offset
- 2);
2938 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2939 contents
+ rel
->r_offset
- 1);
2941 else if (type
== 0x2b)
2944 bfd_put_8 (output_bfd
, 0x81,
2945 contents
+ rel
->r_offset
- 2);
2946 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2947 contents
+ rel
->r_offset
- 1);
2949 else if (type
== 0x03)
2952 bfd_put_8 (output_bfd
, 0x81,
2953 contents
+ rel
->r_offset
- 2);
2954 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2955 contents
+ rel
->r_offset
- 1);
2959 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
2960 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2961 contents
+ rel
->r_offset
);
2963 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2964 contents
+ rel
->r_offset
);
2969 if (htab
->sgot
== NULL
)
2974 off
= h
->got
.offset
;
2975 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
2979 if (local_got_offsets
== NULL
)
2982 off
= local_got_offsets
[r_symndx
];
2983 offplt
= local_tlsdesc_gotents
[r_symndx
];
2990 Elf_Internal_Rela outrel
;
2995 if (htab
->srelgot
== NULL
)
2998 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3000 if (GOT_TLS_GDESC_P (tls_type
))
3002 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
3003 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
3004 <= htab
->sgotplt
->size
);
3005 outrel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3006 + htab
->sgotplt
->output_offset
3008 + htab
->sgotplt_jump_table_size
);
3009 sreloc
= htab
->srelplt
;
3010 loc
= sreloc
->contents
;
3011 loc
+= sreloc
->reloc_count
++
3012 * sizeof (Elf32_External_Rel
);
3013 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3014 <= sreloc
->contents
+ sreloc
->size
);
3015 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3018 BFD_ASSERT (! unresolved_reloc
);
3019 bfd_put_32 (output_bfd
,
3020 relocation
- dtpoff_base (info
),
3021 htab
->sgotplt
->contents
+ offplt
3022 + htab
->sgotplt_jump_table_size
+ 4);
3026 bfd_put_32 (output_bfd
, 0,
3027 htab
->sgotplt
->contents
+ offplt
3028 + htab
->sgotplt_jump_table_size
+ 4);
3032 sreloc
= htab
->srelgot
;
3034 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3035 + htab
->sgot
->output_offset
+ off
);
3037 if (GOT_TLS_GD_P (tls_type
))
3038 dr_type
= R_386_TLS_DTPMOD32
;
3039 else if (GOT_TLS_GDESC_P (tls_type
))
3041 else if (tls_type
== GOT_TLS_IE_POS
)
3042 dr_type
= R_386_TLS_TPOFF
;
3044 dr_type
= R_386_TLS_TPOFF32
;
3046 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3047 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
3048 htab
->sgot
->contents
+ off
);
3049 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3050 bfd_put_32 (output_bfd
, dtpoff_base (info
) - relocation
,
3051 htab
->sgot
->contents
+ off
);
3052 else if (dr_type
!= R_386_TLS_DESC
)
3053 bfd_put_32 (output_bfd
, 0,
3054 htab
->sgot
->contents
+ off
);
3055 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3057 loc
= sreloc
->contents
;
3058 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3059 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3060 <= sreloc
->contents
+ sreloc
->size
);
3061 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3063 if (GOT_TLS_GD_P (tls_type
))
3067 BFD_ASSERT (! unresolved_reloc
);
3068 bfd_put_32 (output_bfd
,
3069 relocation
- dtpoff_base (info
),
3070 htab
->sgot
->contents
+ off
+ 4);
3074 bfd_put_32 (output_bfd
, 0,
3075 htab
->sgot
->contents
+ off
+ 4);
3076 outrel
.r_info
= ELF32_R_INFO (indx
,
3077 R_386_TLS_DTPOFF32
);
3078 outrel
.r_offset
+= 4;
3079 sreloc
->reloc_count
++;
3080 loc
+= sizeof (Elf32_External_Rel
);
3081 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3082 <= sreloc
->contents
+ sreloc
->size
);
3083 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3086 else if (tls_type
== GOT_TLS_IE_BOTH
)
3088 bfd_put_32 (output_bfd
,
3089 indx
== 0 ? relocation
- dtpoff_base (info
) : 0,
3090 htab
->sgot
->contents
+ off
+ 4);
3091 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3092 outrel
.r_offset
+= 4;
3093 sreloc
->reloc_count
++;
3094 loc
+= sizeof (Elf32_External_Rel
);
3095 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3102 local_got_offsets
[r_symndx
] |= 1;
3105 if (off
>= (bfd_vma
) -2
3106 && ! GOT_TLS_GDESC_P (tls_type
))
3108 if (r_type
== R_386_TLS_GOTDESC
3109 || r_type
== R_386_TLS_DESC_CALL
)
3111 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3112 unresolved_reloc
= FALSE
;
3114 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3116 bfd_vma g_o_t
= htab
->sgotplt
->output_section
->vma
3117 + htab
->sgotplt
->output_offset
;
3118 relocation
= htab
->sgot
->output_section
->vma
3119 + htab
->sgot
->output_offset
+ off
- g_o_t
;
3120 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3121 && tls_type
== GOT_TLS_IE_BOTH
)
3123 if (r_type
== R_386_TLS_IE
)
3124 relocation
+= g_o_t
;
3125 unresolved_reloc
= FALSE
;
3127 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3129 unsigned int val
, type
;
3132 /* GD->IE transition. */
3133 BFD_ASSERT (rel
->r_offset
>= 2);
3134 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3135 BFD_ASSERT (type
== 0x8d || type
== 0x04);
3136 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3137 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3139 BFD_ASSERT (rel
+ 1 < relend
);
3140 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3141 roff
= rel
->r_offset
- 3;
3142 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3145 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3147 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3148 BFD_ASSERT (rel
->r_offset
>= 3);
3149 BFD_ASSERT (bfd_get_8 (input_bfd
,
3150 contents
+ rel
->r_offset
- 3)
3152 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
3157 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3159 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3160 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->size
);
3161 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3162 BFD_ASSERT (bfd_get_8 (input_bfd
,
3163 contents
+ rel
->r_offset
+ 9)
3165 roff
= rel
->r_offset
- 2;
3167 memcpy (contents
+ roff
,
3168 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3169 contents
[roff
+ 7] = 0x80 | (val
& 7);
3170 /* If foo is used only with foo@gotntpoff(%reg) and
3171 foo@indntpoff, but not with foo@gottpoff(%reg), change
3172 subl $foo@gottpoff(%reg), %eax
3174 addl $foo@gotntpoff(%reg), %eax. */
3175 if (r_type
== R_386_TLS_GOTIE
)
3177 contents
[roff
+ 6] = 0x03;
3178 if (tls_type
== GOT_TLS_IE_BOTH
)
3181 bfd_put_32 (output_bfd
,
3182 htab
->sgot
->output_section
->vma
3183 + htab
->sgot
->output_offset
+ off
3184 - htab
->sgotplt
->output_section
->vma
3185 - htab
->sgotplt
->output_offset
,
3186 contents
+ roff
+ 8);
3187 /* Skip R_386_PLT32. */
3191 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3193 /* GDesc -> IE transition.
3194 It's originally something like:
3195 leal x@tlsdesc(%ebx), %eax
3198 movl x@gotntpoff(%ebx), %eax # before nop; nop
3200 movl x@gottpoff(%ebx), %eax # before negl %eax
3202 Registers other than %eax may be set up here. */
3204 unsigned int val
, type
;
3207 /* First, make sure it's a leal adding ebx to a 32-bit
3208 offset into any register, although it's probably
3209 almost always going to be eax. */
3210 roff
= rel
->r_offset
;
3211 BFD_ASSERT (roff
>= 2);
3212 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3213 BFD_ASSERT (type
== 0x8d);
3214 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3215 BFD_ASSERT ((val
& 0xc7) == 0x83);
3216 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
3218 /* Now modify the instruction as appropriate. */
3219 /* To turn a leal into a movl in the form we use it, it
3220 suffices to change the first byte from 0x8d to 0x8b.
3221 aoliva FIXME: should we decide to keep the leal, all
3222 we have to do is remove the statement below, and
3223 adjust the relaxation of R_386_TLS_DESC_CALL. */
3224 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3226 if (tls_type
== GOT_TLS_IE_BOTH
)
3229 bfd_put_32 (output_bfd
,
3230 htab
->sgot
->output_section
->vma
3231 + htab
->sgot
->output_offset
+ off
3232 - htab
->sgotplt
->output_section
->vma
3233 - htab
->sgotplt
->output_offset
,
3237 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3239 /* GDesc -> IE transition.
3247 depending on how we transformed the TLS_GOTDESC above.
3250 unsigned int val
, type
;
3253 /* First, make sure it's a call *(%eax). */
3254 roff
= rel
->r_offset
;
3255 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
3256 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
3257 BFD_ASSERT (type
== 0xff);
3258 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
3259 BFD_ASSERT (val
== 0x10);
3261 /* Now modify the instruction as appropriate. */
3262 if (tls_type
!= GOT_TLS_IE_NEG
)
3265 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
3266 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3271 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
3272 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
3286 /* LD->LE transition:
3288 leal foo(%reg), %eax; call ___tls_get_addr.
3290 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3291 BFD_ASSERT (rel
->r_offset
>= 2);
3292 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
3294 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3295 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3296 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3297 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3299 BFD_ASSERT (rel
+ 1 < relend
);
3300 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3301 memcpy (contents
+ rel
->r_offset
- 2,
3302 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3303 /* Skip R_386_PLT32. */
3308 if (htab
->sgot
== NULL
)
3311 off
= htab
->tls_ldm_got
.offset
;
3316 Elf_Internal_Rela outrel
;
3319 if (htab
->srelgot
== NULL
)
3322 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3323 + htab
->sgot
->output_offset
+ off
);
3325 bfd_put_32 (output_bfd
, 0,
3326 htab
->sgot
->contents
+ off
);
3327 bfd_put_32 (output_bfd
, 0,
3328 htab
->sgot
->contents
+ off
+ 4);
3329 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
3330 loc
= htab
->srelgot
->contents
;
3331 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3332 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3333 htab
->tls_ldm_got
.offset
|= 1;
3335 relocation
= htab
->sgot
->output_section
->vma
3336 + htab
->sgot
->output_offset
+ off
3337 - htab
->sgotplt
->output_section
->vma
3338 - htab
->sgotplt
->output_offset
;
3339 unresolved_reloc
= FALSE
;
3342 case R_386_TLS_LDO_32
:
3343 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
3344 relocation
-= dtpoff_base (info
);
3346 /* When converting LDO to LE, we must negate. */
3347 relocation
= -tpoff (info
, relocation
);
3350 case R_386_TLS_LE_32
:
3354 Elf_Internal_Rela outrel
;
3359 outrel
.r_offset
= rel
->r_offset
3360 + input_section
->output_section
->vma
3361 + input_section
->output_offset
;
3362 if (h
!= NULL
&& h
->dynindx
!= -1)
3366 if (r_type
== R_386_TLS_LE_32
)
3367 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
3369 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3370 sreloc
= elf_section_data (input_section
)->sreloc
;
3373 loc
= sreloc
->contents
;
3374 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3375 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3378 else if (r_type
== R_386_TLS_LE_32
)
3379 relocation
= dtpoff_base (info
) - relocation
;
3381 relocation
-= dtpoff_base (info
);
3383 else if (r_type
== R_386_TLS_LE_32
)
3384 relocation
= tpoff (info
, relocation
);
3386 relocation
= -tpoff (info
, relocation
);
3393 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3394 because such sections are not SEC_ALLOC and thus ld.so will
3395 not process them. */
3396 if (unresolved_reloc
3397 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3400 (*_bfd_error_handler
)
3401 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3404 (long) rel
->r_offset
,
3406 h
->root
.root
.string
);
3410 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3411 contents
, rel
->r_offset
,
3414 if (r
!= bfd_reloc_ok
)
3419 name
= h
->root
.root
.string
;
3422 name
= bfd_elf_string_from_elf_section (input_bfd
,
3423 symtab_hdr
->sh_link
,
3428 name
= bfd_section_name (input_bfd
, sec
);
3431 if (r
== bfd_reloc_overflow
)
3433 if (! ((*info
->callbacks
->reloc_overflow
)
3434 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3435 (bfd_vma
) 0, input_bfd
, input_section
,
3441 (*_bfd_error_handler
)
3442 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3443 input_bfd
, input_section
,
3444 (long) rel
->r_offset
, name
, (int) r
);
3453 /* Finish up dynamic symbol handling. We set the contents of various
3454 dynamic sections here. */
3457 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
3458 struct bfd_link_info
*info
,
3459 struct elf_link_hash_entry
*h
,
3460 Elf_Internal_Sym
*sym
)
3462 struct elf_i386_link_hash_table
*htab
;
3464 htab
= elf_i386_hash_table (info
);
3466 if (h
->plt
.offset
!= (bfd_vma
) -1)
3470 Elf_Internal_Rela rel
;
3473 /* This symbol has an entry in the procedure linkage table. Set
3476 if (h
->dynindx
== -1
3477 || htab
->splt
== NULL
3478 || htab
->sgotplt
== NULL
3479 || htab
->srelplt
== NULL
)
3482 /* Get the index in the procedure linkage table which
3483 corresponds to this symbol. This is the index of this symbol
3484 in all the symbols for which we are making plt entries. The
3485 first entry in the procedure linkage table is reserved. */
3486 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3488 /* Get the offset into the .got table of the entry that
3489 corresponds to this function. Each .got entry is 4 bytes.
3490 The first three are reserved. */
3491 got_offset
= (plt_index
+ 3) * 4;
3493 /* Fill in the entry in the procedure linkage table. */
3496 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
3498 bfd_put_32 (output_bfd
,
3499 (htab
->sgotplt
->output_section
->vma
3500 + htab
->sgotplt
->output_offset
3502 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3504 if (htab
->is_vxworks
)
3506 int s
, k
, reloc_index
;
3508 /* Create the R_386_32 relocation referencing the GOT
3509 for this PLT entry. */
3511 /* S: Current slot number (zero-based). */
3512 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
3513 /* K: Number of relocations for PLTResolve. */
3515 k
= PLTRESOLVE_RELOCS_SHLIB
;
3517 k
= PLTRESOLVE_RELOCS
;
3518 /* Skip the PLTresolve relocations, and the relocations for
3519 the other PLT slots. */
3520 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
3521 loc
= (htab
->srelplt2
->contents
+ reloc_index
3522 * sizeof (Elf32_External_Rel
));
3524 rel
.r_offset
= (htab
->splt
->output_section
->vma
3525 + htab
->splt
->output_offset
3526 + h
->plt
.offset
+ 2),
3527 rel
.r_info
= ELF32_R_INFO (htab
->hgot
->indx
, R_386_32
);
3528 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3530 /* Create the R_386_32 relocation referencing the beginning of
3531 the PLT for this GOT entry. */
3532 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3533 + htab
->sgotplt
->output_offset
3535 rel
.r_info
= ELF32_R_INFO (htab
->hplt
->indx
, R_386_32
);
3536 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3537 loc
+ sizeof (Elf32_External_Rel
));
3542 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
3544 bfd_put_32 (output_bfd
, got_offset
,
3545 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3548 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
3549 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
3550 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
3551 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
3553 /* Fill in the entry in the global offset table. */
3554 bfd_put_32 (output_bfd
,
3555 (htab
->splt
->output_section
->vma
3556 + htab
->splt
->output_offset
3559 htab
->sgotplt
->contents
+ got_offset
);
3561 /* Fill in the entry in the .rel.plt section. */
3562 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3563 + htab
->sgotplt
->output_offset
3565 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
3566 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3567 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3569 if (!h
->def_regular
)
3571 /* Mark the symbol as undefined, rather than as defined in
3572 the .plt section. Leave the value if there were any
3573 relocations where pointer equality matters (this is a clue
3574 for the dynamic linker, to make function pointer
3575 comparisons work between an application and shared
3576 library), otherwise set it to zero. If a function is only
3577 called from a binary, there is no need to slow down
3578 shared libraries because of that. */
3579 sym
->st_shndx
= SHN_UNDEF
;
3580 if (!h
->pointer_equality_needed
)
3585 if (h
->got
.offset
!= (bfd_vma
) -1
3586 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
3587 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
3589 Elf_Internal_Rela rel
;
3592 /* This symbol has an entry in the global offset table. Set it
3595 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
3598 rel
.r_offset
= (htab
->sgot
->output_section
->vma
3599 + htab
->sgot
->output_offset
3600 + (h
->got
.offset
& ~(bfd_vma
) 1));
3602 /* If this is a static link, or it is a -Bsymbolic link and the
3603 symbol is defined locally or was forced to be local because
3604 of a version file, we just want to emit a RELATIVE reloc.
3605 The entry in the global offset table will already have been
3606 initialized in the relocate_section function. */
3608 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3610 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3611 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3615 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3616 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
3617 htab
->sgot
->contents
+ h
->got
.offset
);
3618 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
3621 loc
= htab
->srelgot
->contents
;
3622 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3623 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3628 Elf_Internal_Rela rel
;
3631 /* This symbol needs a copy reloc. Set it up. */
3633 if (h
->dynindx
== -1
3634 || (h
->root
.type
!= bfd_link_hash_defined
3635 && h
->root
.type
!= bfd_link_hash_defweak
)
3636 || htab
->srelbss
== NULL
)
3639 rel
.r_offset
= (h
->root
.u
.def
.value
3640 + h
->root
.u
.def
.section
->output_section
->vma
3641 + h
->root
.u
.def
.section
->output_offset
);
3642 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
3643 loc
= htab
->srelbss
->contents
;
3644 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3645 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3648 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3649 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3650 is relative to the ".got" section. */
3651 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3652 || (strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3653 && !htab
->is_vxworks
))
3654 sym
->st_shndx
= SHN_ABS
;
3659 /* Used to decide how to sort relocs in an optimal manner for the
3660 dynamic linker, before writing them out. */
3662 static enum elf_reloc_type_class
3663 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
3665 switch (ELF32_R_TYPE (rela
->r_info
))
3667 case R_386_RELATIVE
:
3668 return reloc_class_relative
;
3669 case R_386_JUMP_SLOT
:
3670 return reloc_class_plt
;
3672 return reloc_class_copy
;
3674 return reloc_class_normal
;
3678 /* Finish up the dynamic sections. */
3681 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
3682 struct bfd_link_info
*info
)
3684 struct elf_i386_link_hash_table
*htab
;
3688 htab
= elf_i386_hash_table (info
);
3689 dynobj
= htab
->elf
.dynobj
;
3690 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3692 if (htab
->elf
.dynamic_sections_created
)
3694 Elf32_External_Dyn
*dyncon
, *dynconend
;
3696 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3699 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3700 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3701 for (; dyncon
< dynconend
; dyncon
++)
3703 Elf_Internal_Dyn dyn
;
3706 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3715 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3720 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3725 dyn
.d_un
.d_val
= s
->size
;
3729 /* My reading of the SVR4 ABI indicates that the
3730 procedure linkage table relocs (DT_JMPREL) should be
3731 included in the overall relocs (DT_REL). This is
3732 what Solaris does. However, UnixWare can not handle
3733 that case. Therefore, we override the DT_RELSZ entry
3734 here to make it not include the JMPREL relocs. */
3738 dyn
.d_un
.d_val
-= s
->size
;
3742 /* We may not be using the standard ELF linker script.
3743 If .rel.plt is the first .rel section, we adjust
3744 DT_REL to not include it. */
3748 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
3750 dyn
.d_un
.d_ptr
+= s
->size
;
3754 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3757 /* Fill in the first entry in the procedure linkage table. */
3758 if (htab
->splt
&& htab
->splt
->size
> 0)
3762 memcpy (htab
->splt
->contents
, elf_i386_pic_plt0_entry
,
3763 sizeof (elf_i386_pic_plt0_entry
));
3764 memset (htab
->splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
3765 htab
->plt0_pad_byte
,
3766 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
3770 memcpy (htab
->splt
->contents
, elf_i386_plt0_entry
,
3771 sizeof(elf_i386_plt0_entry
));
3772 memset (htab
->splt
->contents
+ sizeof (elf_i386_plt0_entry
),
3773 htab
->plt0_pad_byte
,
3774 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
3775 bfd_put_32 (output_bfd
,
3776 (htab
->sgotplt
->output_section
->vma
3777 + htab
->sgotplt
->output_offset
3779 htab
->splt
->contents
+ 2);
3780 bfd_put_32 (output_bfd
,
3781 (htab
->sgotplt
->output_section
->vma
3782 + htab
->sgotplt
->output_offset
3784 htab
->splt
->contents
+ 8);
3786 if (htab
->is_vxworks
)
3788 Elf_Internal_Rela rel
;
3789 struct elf_link_hash_entry
*hgot
;
3791 /* The VxWorks GOT is relocated by the dynamic linker.
3792 Therefore, we must emit relocations rather than
3793 simply computing the values now. */
3794 hgot
= elf_link_hash_lookup (elf_hash_table (info
),
3795 "_GLOBAL_OFFSET_TABLE_",
3796 FALSE
, FALSE
, FALSE
);
3797 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3798 On IA32 we use REL relocations so the addend goes in
3799 the PLT directly. */
3800 rel
.r_offset
= (htab
->splt
->output_section
->vma
3801 + htab
->splt
->output_offset
3803 rel
.r_info
= ELF32_R_INFO (hgot
->indx
, R_386_32
);
3804 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3805 htab
->srelplt2
->contents
);
3806 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
3807 rel
.r_offset
= (htab
->splt
->output_section
->vma
3808 + htab
->splt
->output_offset
3810 rel
.r_info
= ELF32_R_INFO (hgot
->indx
, R_386_32
);
3811 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3812 htab
->srelplt2
->contents
+
3813 sizeof (Elf32_External_Rel
));
3817 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3818 really seem like the right value. */
3819 elf_section_data (htab
->splt
->output_section
)
3820 ->this_hdr
.sh_entsize
= 4;
3822 /* Correct the .rel.plt.unloaded relocations. */
3823 if (htab
->is_vxworks
&& !info
->shared
)
3825 int num_plts
= (htab
->splt
->size
/ PLT_ENTRY_SIZE
) - 1;
3828 p
= htab
->srelplt2
->contents
;
3830 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
3832 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
3834 for (; num_plts
; num_plts
--)
3836 Elf_Internal_Rela rel
;
3837 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3838 rel
.r_info
= ELF32_R_INFO (htab
->hgot
->indx
, R_386_32
);
3839 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3840 p
+= sizeof (Elf32_External_Rel
);
3842 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3843 rel
.r_info
= ELF32_R_INFO (htab
->hplt
->indx
, R_386_32
);
3844 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3845 p
+= sizeof (Elf32_External_Rel
);
3853 /* Fill in the first three entries in the global offset table. */
3854 if (htab
->sgotplt
->size
> 0)
3856 bfd_put_32 (output_bfd
,
3858 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3859 htab
->sgotplt
->contents
);
3860 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 4);
3861 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 8);
3864 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3867 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3868 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3873 /* Return address for Ith PLT stub in section PLT, for relocation REL
3874 or (bfd_vma) -1 if it should not be included. */
3877 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
3878 const arelent
*rel ATTRIBUTE_UNUSED
)
3880 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
3884 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3885 #define TARGET_LITTLE_NAME "elf32-i386"
3886 #define ELF_ARCH bfd_arch_i386
3887 #define ELF_MACHINE_CODE EM_386
3888 #define ELF_MAXPAGESIZE 0x1000
3890 #define elf_backend_can_gc_sections 1
3891 #define elf_backend_can_refcount 1
3892 #define elf_backend_want_got_plt 1
3893 #define elf_backend_plt_readonly 1
3894 #define elf_backend_want_plt_sym 0
3895 #define elf_backend_got_header_size 12
3897 /* Support RELA for objdump of prelink objects. */
3898 #define elf_info_to_howto elf_i386_info_to_howto_rel
3899 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3901 #define bfd_elf32_mkobject elf_i386_mkobject
3903 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3904 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3905 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3907 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3908 #define elf_backend_check_relocs elf_i386_check_relocs
3909 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3910 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3911 #define elf_backend_fake_sections elf_i386_fake_sections
3912 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3913 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3914 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3915 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3916 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3917 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3918 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3919 #define elf_backend_relocate_section elf_i386_relocate_section
3920 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3921 #define elf_backend_always_size_sections elf_i386_always_size_sections
3922 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
3924 #include "elf32-target.h"
3926 /* FreeBSD support. */
3928 #undef TARGET_LITTLE_SYM
3929 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3930 #undef TARGET_LITTLE_NAME
3931 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3933 /* The kernel recognizes executables as valid only if they carry a
3934 "FreeBSD" label in the ELF header. So we put this label on all
3935 executables and (for simplicity) also all other object files. */
3938 elf_i386_post_process_headers (bfd
*abfd
,
3939 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3941 Elf_Internal_Ehdr
*i_ehdrp
;
3943 i_ehdrp
= elf_elfheader (abfd
);
3945 /* Put an ABI label supported by FreeBSD >= 4.1. */
3946 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
3947 #ifdef OLD_FREEBSD_ABI_LABEL
3948 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3949 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
3953 #undef elf_backend_post_process_headers
3954 #define elf_backend_post_process_headers elf_i386_post_process_headers
3956 #define elf32_bed elf32_i386_fbsd_bed
3958 #include "elf32-target.h"
3960 /* VxWorks support. */
3962 #undef TARGET_LITTLE_SYM
3963 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
3964 #undef TARGET_LITTLE_NAME
3965 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
3968 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
3970 static struct bfd_link_hash_table
*
3971 elf_i386_vxworks_link_hash_table_create (bfd
*abfd
)
3973 struct bfd_link_hash_table
*ret
;
3974 struct elf_i386_link_hash_table
*htab
;
3976 ret
= elf_i386_link_hash_table_create (abfd
);
3979 htab
= (struct elf_i386_link_hash_table
*) ret
;
3980 htab
->is_vxworks
= 1;
3981 htab
->plt0_pad_byte
= 0x90;
3988 /* Tweak magic VxWorks symbols as they are written to the output file. */
3990 elf_i386_vxworks_link_output_symbol_hook (struct bfd_link_info
*info
3993 Elf_Internal_Sym
*sym
,
3994 asection
*input_sec ATTRIBUTE_UNUSED
,
3995 struct elf_link_hash_entry
*h
3998 /* Ignore the first dummy symbol. */
4002 return elf_vxworks_link_output_symbol_hook (name
, sym
);
4005 #undef elf_backend_post_process_headers
4006 #undef bfd_elf32_bfd_link_hash_table_create
4007 #define bfd_elf32_bfd_link_hash_table_create \
4008 elf_i386_vxworks_link_hash_table_create
4009 #undef elf_backend_add_symbol_hook
4010 #define elf_backend_add_symbol_hook \
4011 elf_vxworks_add_symbol_hook
4012 #undef elf_backend_link_output_symbol_hook
4013 #define elf_backend_link_output_symbol_hook \
4014 elf_i386_vxworks_link_output_symbol_hook
4015 #undef elf_backend_emit_relocs
4016 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4017 #undef elf_backend_final_write_processing
4018 #define elf_backend_final_write_processing \
4019 elf_vxworks_final_write_processing
4021 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4023 #undef elf_backend_want_plt_sym
4024 #define elf_backend_want_plt_sym 1
4027 #define elf32_bed elf32_i386_vxworks_bed
4029 #include "elf32-target.h"