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 /* True if the target system is VxWorks. */
653 /* Value used to fill the last word of the first plt entry. */
654 bfd_byte plt0_pad_byte
;
657 bfd_signed_vma refcount
;
661 /* The amount of space used by the reserved portion of the sgotplt
662 section, plus whatever space is used by the jump slots. */
663 bfd_vma sgotplt_jump_table_size
;
665 /* Small local sym to section mapping cache. */
666 struct sym_sec_cache sym_sec
;
669 /* Get the i386 ELF linker hash table from a link_info structure. */
671 #define elf_i386_hash_table(p) \
672 ((struct elf_i386_link_hash_table *) ((p)->hash))
674 #define elf_i386_compute_jump_table_size(htab) \
675 ((htab)->srelplt->reloc_count * 4)
677 /* Create an entry in an i386 ELF linker hash table. */
679 static struct bfd_hash_entry
*
680 link_hash_newfunc (struct bfd_hash_entry
*entry
,
681 struct bfd_hash_table
*table
,
684 /* Allocate the structure if it has not already been allocated by a
688 entry
= bfd_hash_allocate (table
,
689 sizeof (struct elf_i386_link_hash_entry
));
694 /* Call the allocation method of the superclass. */
695 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
698 struct elf_i386_link_hash_entry
*eh
;
700 eh
= (struct elf_i386_link_hash_entry
*) entry
;
701 eh
->dyn_relocs
= NULL
;
702 eh
->tls_type
= GOT_UNKNOWN
;
703 eh
->tlsdesc_got
= (bfd_vma
) -1;
709 /* Create an i386 ELF linker hash table. */
711 static struct bfd_link_hash_table
*
712 elf_i386_link_hash_table_create (bfd
*abfd
)
714 struct elf_i386_link_hash_table
*ret
;
715 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
717 ret
= bfd_malloc (amt
);
721 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
734 ret
->tls_ldm_got
.refcount
= 0;
735 ret
->sgotplt_jump_table_size
= 0;
736 ret
->sym_sec
.abfd
= NULL
;
738 ret
->srelplt2
= NULL
;
739 ret
->plt0_pad_byte
= 0;
741 return &ret
->elf
.root
;
744 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
745 shortcuts to them in our hash table. */
748 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
750 struct elf_i386_link_hash_table
*htab
;
752 if (! _bfd_elf_create_got_section (dynobj
, info
))
755 htab
= elf_i386_hash_table (info
);
756 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
757 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
758 if (!htab
->sgot
|| !htab
->sgotplt
)
761 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rel.got",
762 (SEC_ALLOC
| SEC_LOAD
767 if (htab
->srelgot
== NULL
768 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
773 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
774 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
778 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
780 struct elf_i386_link_hash_table
*htab
;
783 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
785 htab
= elf_i386_hash_table (info
);
786 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
789 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
792 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
793 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
794 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
796 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
798 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
799 || (!info
->shared
&& !htab
->srelbss
))
802 if (htab
->is_vxworks
&& !info
->shared
)
804 s
= bfd_make_section (dynobj
, ".rel.plt.unloaded");
805 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_READONLY
806 | SEC_LINKER_CREATED
);
808 || ! bfd_set_section_flags (dynobj
, s
, flags
)
809 || ! bfd_set_section_alignment (dynobj
, s
, bed
->s
->log_file_align
))
817 /* Copy the extra info we tack onto an elf_link_hash_entry. */
820 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
821 struct elf_link_hash_entry
*dir
,
822 struct elf_link_hash_entry
*ind
)
824 struct elf_i386_link_hash_entry
*edir
, *eind
;
826 edir
= (struct elf_i386_link_hash_entry
*) dir
;
827 eind
= (struct elf_i386_link_hash_entry
*) ind
;
829 if (eind
->dyn_relocs
!= NULL
)
831 if (edir
->dyn_relocs
!= NULL
)
833 struct elf_i386_dyn_relocs
**pp
;
834 struct elf_i386_dyn_relocs
*p
;
836 /* Add reloc counts against the indirect sym to the direct sym
837 list. Merge any entries against the same section. */
838 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
840 struct elf_i386_dyn_relocs
*q
;
842 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
843 if (q
->sec
== p
->sec
)
845 q
->pc_count
+= p
->pc_count
;
846 q
->count
+= p
->count
;
853 *pp
= edir
->dyn_relocs
;
856 edir
->dyn_relocs
= eind
->dyn_relocs
;
857 eind
->dyn_relocs
= NULL
;
860 if (ind
->root
.type
== bfd_link_hash_indirect
861 && dir
->got
.refcount
<= 0)
863 edir
->tls_type
= eind
->tls_type
;
864 eind
->tls_type
= GOT_UNKNOWN
;
867 if (ELIMINATE_COPY_RELOCS
868 && ind
->root
.type
!= bfd_link_hash_indirect
869 && dir
->dynamic_adjusted
)
871 /* If called to transfer flags for a weakdef during processing
872 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
873 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
874 dir
->ref_dynamic
|= ind
->ref_dynamic
;
875 dir
->ref_regular
|= ind
->ref_regular
;
876 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
877 dir
->needs_plt
|= ind
->needs_plt
;
878 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
881 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
885 elf_i386_tls_transition (struct bfd_link_info
*info
, int r_type
, int is_local
)
893 case R_386_TLS_GOTDESC
:
894 case R_386_TLS_DESC_CALL
:
895 case R_386_TLS_IE_32
:
897 return R_386_TLS_LE_32
;
898 return R_386_TLS_IE_32
;
900 case R_386_TLS_GOTIE
:
902 return R_386_TLS_LE_32
;
905 return R_386_TLS_LE_32
;
911 /* Look through the relocs for a section during the first phase, and
912 calculate needed space in the global offset table, procedure linkage
913 table, and dynamic reloc sections. */
916 elf_i386_check_relocs (bfd
*abfd
,
917 struct bfd_link_info
*info
,
919 const Elf_Internal_Rela
*relocs
)
921 struct elf_i386_link_hash_table
*htab
;
922 Elf_Internal_Shdr
*symtab_hdr
;
923 struct elf_link_hash_entry
**sym_hashes
;
924 const Elf_Internal_Rela
*rel
;
925 const Elf_Internal_Rela
*rel_end
;
928 if (info
->relocatable
)
931 htab
= elf_i386_hash_table (info
);
932 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
933 sym_hashes
= elf_sym_hashes (abfd
);
937 rel_end
= relocs
+ sec
->reloc_count
;
938 for (rel
= relocs
; rel
< rel_end
; rel
++)
941 unsigned long r_symndx
;
942 struct elf_link_hash_entry
*h
;
944 r_symndx
= ELF32_R_SYM (rel
->r_info
);
945 r_type
= ELF32_R_TYPE (rel
->r_info
);
947 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
949 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
955 if (r_symndx
< symtab_hdr
->sh_info
)
959 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
960 while (h
->root
.type
== bfd_link_hash_indirect
961 || h
->root
.type
== bfd_link_hash_warning
)
962 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
965 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
970 htab
->tls_ldm_got
.refcount
+= 1;
974 /* This symbol requires a procedure linkage table entry. We
975 actually build the entry in adjust_dynamic_symbol,
976 because this might be a case of linking PIC code which is
977 never referenced by a dynamic object, in which case we
978 don't need to generate a procedure linkage table entry
981 /* If this is a local symbol, we resolve it directly without
982 creating a procedure linkage table entry. */
987 h
->plt
.refcount
+= 1;
990 case R_386_TLS_IE_32
:
992 case R_386_TLS_GOTIE
:
994 info
->flags
|= DF_STATIC_TLS
;
999 case R_386_TLS_GOTDESC
:
1000 case R_386_TLS_DESC_CALL
:
1001 /* This symbol requires a global offset table entry. */
1003 int tls_type
, old_tls_type
;
1008 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1009 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1010 case R_386_TLS_GOTDESC
:
1011 case R_386_TLS_DESC_CALL
:
1012 tls_type
= GOT_TLS_GDESC
; break;
1013 case R_386_TLS_IE_32
:
1014 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1015 tls_type
= GOT_TLS_IE_NEG
;
1017 /* If this is a GD->IE transition, we may use either of
1018 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1019 tls_type
= GOT_TLS_IE
;
1022 case R_386_TLS_GOTIE
:
1023 tls_type
= GOT_TLS_IE_POS
; break;
1028 h
->got
.refcount
+= 1;
1029 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1033 bfd_signed_vma
*local_got_refcounts
;
1035 /* This is a global offset table entry for a local symbol. */
1036 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1037 if (local_got_refcounts
== NULL
)
1041 size
= symtab_hdr
->sh_info
;
1042 size
*= (sizeof (bfd_signed_vma
)
1043 + sizeof (bfd_vma
) + sizeof(char));
1044 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1045 if (local_got_refcounts
== NULL
)
1047 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1048 elf_i386_local_tlsdesc_gotent (abfd
)
1049 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1050 elf_i386_local_got_tls_type (abfd
)
1051 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1053 local_got_refcounts
[r_symndx
] += 1;
1054 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1057 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1058 tls_type
|= old_tls_type
;
1059 /* If a TLS symbol is accessed using IE at least once,
1060 there is no point to use dynamic model for it. */
1061 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1062 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1063 || (tls_type
& GOT_TLS_IE
) == 0))
1065 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1066 tls_type
= old_tls_type
;
1067 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1068 && GOT_TLS_GD_ANY_P (tls_type
))
1069 tls_type
|= old_tls_type
;
1072 (*_bfd_error_handler
)
1073 (_("%B: `%s' accessed both as normal and "
1074 "thread local symbol"),
1076 h
? h
->root
.root
.string
: "<local>");
1081 if (old_tls_type
!= tls_type
)
1084 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1086 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1094 if (htab
->sgot
== NULL
)
1096 if (htab
->elf
.dynobj
== NULL
)
1097 htab
->elf
.dynobj
= abfd
;
1098 if (!create_got_section (htab
->elf
.dynobj
, info
))
1101 if (r_type
!= R_386_TLS_IE
)
1105 case R_386_TLS_LE_32
:
1109 info
->flags
|= DF_STATIC_TLS
;
1114 if (h
!= NULL
&& !info
->shared
)
1116 /* If this reloc is in a read-only section, we might
1117 need a copy reloc. We can't check reliably at this
1118 stage whether the section is read-only, as input
1119 sections have not yet been mapped to output sections.
1120 Tentatively set the flag for now, and correct in
1121 adjust_dynamic_symbol. */
1124 /* We may need a .plt entry if the function this reloc
1125 refers to is in a shared lib. */
1126 h
->plt
.refcount
+= 1;
1127 if (r_type
!= R_386_PC32
)
1128 h
->pointer_equality_needed
= 1;
1131 /* If we are creating a shared library, and this is a reloc
1132 against a global symbol, or a non PC relative reloc
1133 against a local symbol, then we need to copy the reloc
1134 into the shared library. However, if we are linking with
1135 -Bsymbolic, we do not need to copy a reloc against a
1136 global symbol which is defined in an object we are
1137 including in the link (i.e., DEF_REGULAR is set). At
1138 this point we have not seen all the input files, so it is
1139 possible that DEF_REGULAR is not set now but will be set
1140 later (it is never cleared). In case of a weak definition,
1141 DEF_REGULAR may be cleared later by a strong definition in
1142 a shared library. We account for that possibility below by
1143 storing information in the relocs_copied field of the hash
1144 table entry. A similar situation occurs when creating
1145 shared libraries and symbol visibility changes render the
1148 If on the other hand, we are creating an executable, we
1149 may need to keep relocations for symbols satisfied by a
1150 dynamic library if we manage to avoid copy relocs for the
1153 && (sec
->flags
& SEC_ALLOC
) != 0
1154 && (r_type
!= R_386_PC32
1156 && (! info
->symbolic
1157 || h
->root
.type
== bfd_link_hash_defweak
1158 || !h
->def_regular
))))
1159 || (ELIMINATE_COPY_RELOCS
1161 && (sec
->flags
& SEC_ALLOC
) != 0
1163 && (h
->root
.type
== bfd_link_hash_defweak
1164 || !h
->def_regular
)))
1166 struct elf_i386_dyn_relocs
*p
;
1167 struct elf_i386_dyn_relocs
**head
;
1169 /* We must copy these reloc types into the output file.
1170 Create a reloc section in dynobj and make room for
1176 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1177 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1179 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1183 if (strncmp (name
, ".rel", 4) != 0
1184 || strcmp (bfd_get_section_name (abfd
, sec
),
1187 (*_bfd_error_handler
)
1188 (_("%B: bad relocation section name `%s\'"),
1192 if (htab
->elf
.dynobj
== NULL
)
1193 htab
->elf
.dynobj
= abfd
;
1195 dynobj
= htab
->elf
.dynobj
;
1196 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1201 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1202 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1203 if ((sec
->flags
& SEC_ALLOC
) != 0)
1204 flags
|= SEC_ALLOC
| SEC_LOAD
;
1205 sreloc
= bfd_make_section_with_flags (dynobj
,
1209 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1212 elf_section_data (sec
)->sreloc
= sreloc
;
1215 /* If this is a global symbol, we count the number of
1216 relocations we need for this symbol. */
1219 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1224 /* Track dynamic relocs needed for local syms too.
1225 We really need local syms available to do this
1229 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1234 vpp
= &elf_section_data (s
)->local_dynrel
;
1235 head
= (struct elf_i386_dyn_relocs
**)vpp
;
1239 if (p
== NULL
|| p
->sec
!= sec
)
1241 bfd_size_type amt
= sizeof *p
;
1242 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1253 if (r_type
== R_386_PC32
)
1258 /* This relocation describes the C++ object vtable hierarchy.
1259 Reconstruct it for later use during GC. */
1260 case R_386_GNU_VTINHERIT
:
1261 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1265 /* This relocation describes which C++ vtable entries are actually
1266 used. Record for later use during GC. */
1267 case R_386_GNU_VTENTRY
:
1268 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1280 /* Return the section that should be marked against GC for a given
1284 elf_i386_gc_mark_hook (asection
*sec
,
1285 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1286 Elf_Internal_Rela
*rel
,
1287 struct elf_link_hash_entry
*h
,
1288 Elf_Internal_Sym
*sym
)
1292 switch (ELF32_R_TYPE (rel
->r_info
))
1294 case R_386_GNU_VTINHERIT
:
1295 case R_386_GNU_VTENTRY
:
1299 switch (h
->root
.type
)
1301 case bfd_link_hash_defined
:
1302 case bfd_link_hash_defweak
:
1303 return h
->root
.u
.def
.section
;
1305 case bfd_link_hash_common
:
1306 return h
->root
.u
.c
.p
->section
;
1314 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1319 /* Update the got entry reference counts for the section being removed. */
1322 elf_i386_gc_sweep_hook (bfd
*abfd
,
1323 struct bfd_link_info
*info
,
1325 const Elf_Internal_Rela
*relocs
)
1327 Elf_Internal_Shdr
*symtab_hdr
;
1328 struct elf_link_hash_entry
**sym_hashes
;
1329 bfd_signed_vma
*local_got_refcounts
;
1330 const Elf_Internal_Rela
*rel
, *relend
;
1332 elf_section_data (sec
)->local_dynrel
= NULL
;
1334 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1335 sym_hashes
= elf_sym_hashes (abfd
);
1336 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1338 relend
= relocs
+ sec
->reloc_count
;
1339 for (rel
= relocs
; rel
< relend
; rel
++)
1341 unsigned long r_symndx
;
1342 unsigned int r_type
;
1343 struct elf_link_hash_entry
*h
= NULL
;
1345 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1346 if (r_symndx
>= symtab_hdr
->sh_info
)
1348 struct elf_i386_link_hash_entry
*eh
;
1349 struct elf_i386_dyn_relocs
**pp
;
1350 struct elf_i386_dyn_relocs
*p
;
1352 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1353 while (h
->root
.type
== bfd_link_hash_indirect
1354 || h
->root
.type
== bfd_link_hash_warning
)
1355 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1356 eh
= (struct elf_i386_link_hash_entry
*) h
;
1358 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1361 /* Everything must go for SEC. */
1367 r_type
= ELF32_R_TYPE (rel
->r_info
);
1368 r_type
= elf_i386_tls_transition (info
, r_type
, h
!= NULL
);
1372 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1373 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1377 case R_386_TLS_GOTDESC
:
1378 case R_386_TLS_DESC_CALL
:
1379 case R_386_TLS_IE_32
:
1381 case R_386_TLS_GOTIE
:
1385 if (h
->got
.refcount
> 0)
1386 h
->got
.refcount
-= 1;
1388 else if (local_got_refcounts
!= NULL
)
1390 if (local_got_refcounts
[r_symndx
] > 0)
1391 local_got_refcounts
[r_symndx
] -= 1;
1404 if (h
->plt
.refcount
> 0)
1405 h
->plt
.refcount
-= 1;
1417 /* Adjust a symbol defined by a dynamic object and referenced by a
1418 regular object. The current definition is in some section of the
1419 dynamic object, but we're not including those sections. We have to
1420 change the definition to something the rest of the link can
1424 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1425 struct elf_link_hash_entry
*h
)
1427 struct elf_i386_link_hash_table
*htab
;
1429 unsigned int power_of_two
;
1431 /* If this is a function, put it in the procedure linkage table. We
1432 will fill in the contents of the procedure linkage table later,
1433 when we know the address of the .got section. */
1434 if (h
->type
== STT_FUNC
1437 if (h
->plt
.refcount
<= 0
1438 || SYMBOL_CALLS_LOCAL (info
, h
)
1439 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1440 && h
->root
.type
== bfd_link_hash_undefweak
))
1442 /* This case can occur if we saw a PLT32 reloc in an input
1443 file, but the symbol was never referred to by a dynamic
1444 object, or if all references were garbage collected. In
1445 such a case, we don't actually need to build a procedure
1446 linkage table, and we can just do a PC32 reloc instead. */
1447 h
->plt
.offset
= (bfd_vma
) -1;
1454 /* It's possible that we incorrectly decided a .plt reloc was
1455 needed for an R_386_PC32 reloc to a non-function sym in
1456 check_relocs. We can't decide accurately between function and
1457 non-function syms in check-relocs; Objects loaded later in
1458 the link may change h->type. So fix it now. */
1459 h
->plt
.offset
= (bfd_vma
) -1;
1461 /* If this is a weak symbol, and there is a real definition, the
1462 processor independent code will have arranged for us to see the
1463 real definition first, and we can just use the same value. */
1464 if (h
->u
.weakdef
!= NULL
)
1466 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1467 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1468 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1469 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1470 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1471 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1475 /* This is a reference to a symbol defined by a dynamic object which
1476 is not a function. */
1478 /* If we are creating a shared library, we must presume that the
1479 only references to the symbol are via the global offset table.
1480 For such cases we need not do anything here; the relocations will
1481 be handled correctly by relocate_section. */
1485 /* If there are no references to this symbol that do not use the
1486 GOT, we don't need to generate a copy reloc. */
1487 if (!h
->non_got_ref
)
1490 /* If -z nocopyreloc was given, we won't generate them either. */
1491 if (info
->nocopyreloc
)
1497 htab
= elf_i386_hash_table (info
);
1499 /* If there aren't any dynamic relocs in read-only sections, then
1500 we can keep the dynamic relocs and avoid the copy reloc. This
1501 doesn't work on VxWorks, where we can not have dynamic relocations
1502 (other than copy and jump slot relocations) in an executable. */
1503 if (ELIMINATE_COPY_RELOCS
&& !htab
->is_vxworks
)
1505 struct elf_i386_link_hash_entry
* eh
;
1506 struct elf_i386_dyn_relocs
*p
;
1508 eh
= (struct elf_i386_link_hash_entry
*) h
;
1509 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1511 s
= p
->sec
->output_section
;
1512 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1525 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1526 h
->root
.root
.string
);
1530 /* We must allocate the symbol in our .dynbss section, which will
1531 become part of the .bss section of the executable. There will be
1532 an entry for this symbol in the .dynsym section. The dynamic
1533 object will contain position independent code, so all references
1534 from the dynamic object to this symbol will go through the global
1535 offset table. The dynamic linker will use the .dynsym entry to
1536 determine the address it must put in the global offset table, so
1537 both the dynamic object and the regular object will refer to the
1538 same memory location for the variable. */
1540 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1541 copy the initial value out of the dynamic object and into the
1542 runtime process image. */
1543 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1545 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
1549 /* We need to figure out the alignment required for this symbol. I
1550 have no idea how ELF linkers handle this. */
1551 power_of_two
= bfd_log2 (h
->size
);
1552 if (power_of_two
> 3)
1555 /* Apply the required alignment. */
1557 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1558 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1560 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1564 /* Define the symbol as being at this point in the section. */
1565 h
->root
.u
.def
.section
= s
;
1566 h
->root
.u
.def
.value
= s
->size
;
1568 /* Increment the section size to make room for the symbol. */
1574 /* Allocate space in .plt, .got and associated reloc sections for
1578 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1580 struct bfd_link_info
*info
;
1581 struct elf_i386_link_hash_table
*htab
;
1582 struct elf_i386_link_hash_entry
*eh
;
1583 struct elf_i386_dyn_relocs
*p
;
1585 if (h
->root
.type
== bfd_link_hash_indirect
)
1588 if (h
->root
.type
== bfd_link_hash_warning
)
1589 /* When warning symbols are created, they **replace** the "real"
1590 entry in the hash table, thus we never get to see the real
1591 symbol in a hash traversal. So look at it now. */
1592 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1594 info
= (struct bfd_link_info
*) inf
;
1595 htab
= elf_i386_hash_table (info
);
1597 if (htab
->elf
.dynamic_sections_created
1598 && h
->plt
.refcount
> 0)
1600 /* Make sure this symbol is output as a dynamic symbol.
1601 Undefined weak syms won't yet be marked as dynamic. */
1602 if (h
->dynindx
== -1
1603 && !h
->forced_local
)
1605 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1610 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1612 asection
*s
= htab
->splt
;
1614 /* If this is the first .plt entry, make room for the special
1617 s
->size
+= PLT_ENTRY_SIZE
;
1619 h
->plt
.offset
= s
->size
;
1621 /* If this symbol is not defined in a regular file, and we are
1622 not generating a shared library, then set the symbol to this
1623 location in the .plt. This is required to make function
1624 pointers compare as equal between the normal executable and
1625 the shared library. */
1629 h
->root
.u
.def
.section
= s
;
1630 h
->root
.u
.def
.value
= h
->plt
.offset
;
1633 /* Make room for this entry. */
1634 s
->size
+= PLT_ENTRY_SIZE
;
1636 /* We also need to make an entry in the .got.plt section, which
1637 will be placed in the .got section by the linker script. */
1638 htab
->sgotplt
->size
+= 4;
1640 /* We also need to make an entry in the .rel.plt section. */
1641 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1642 htab
->srelplt
->reloc_count
++;
1644 if (htab
->is_vxworks
&& !info
->shared
)
1646 /* VxWorks has a second set of relocations for each PLT entry
1647 in executables. They go in a separate relocation section,
1648 which is processed by the kernel loader. */
1650 /* There are two relocations for the initial PLT entry: an
1651 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1652 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1654 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
1655 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1657 /* There are two extra relocations for each subsequent PLT entry:
1658 an R_386_32 relocation for the GOT entry, and an R_386_32
1659 relocation for the PLT entry. */
1661 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1666 h
->plt
.offset
= (bfd_vma
) -1;
1672 h
->plt
.offset
= (bfd_vma
) -1;
1676 eh
= (struct elf_i386_link_hash_entry
*) h
;
1677 eh
->tlsdesc_got
= (bfd_vma
) -1;
1679 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1680 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1681 if (h
->got
.refcount
> 0
1684 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
1685 h
->got
.offset
= (bfd_vma
) -1;
1686 else if (h
->got
.refcount
> 0)
1690 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1692 /* Make sure this symbol is output as a dynamic symbol.
1693 Undefined weak syms won't yet be marked as dynamic. */
1694 if (h
->dynindx
== -1
1695 && !h
->forced_local
)
1697 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1702 if (GOT_TLS_GDESC_P (tls_type
))
1704 eh
->tlsdesc_got
= htab
->sgotplt
->size
1705 - elf_i386_compute_jump_table_size (htab
);
1706 htab
->sgotplt
->size
+= 8;
1707 h
->got
.offset
= (bfd_vma
) -2;
1709 if (! GOT_TLS_GDESC_P (tls_type
)
1710 || GOT_TLS_GD_P (tls_type
))
1712 h
->got
.offset
= s
->size
;
1714 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1715 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
1718 dyn
= htab
->elf
.dynamic_sections_created
;
1719 /* R_386_TLS_IE_32 needs one dynamic relocation,
1720 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1721 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1722 need two), R_386_TLS_GD needs one if local symbol and two if
1724 if (tls_type
== GOT_TLS_IE_BOTH
)
1725 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1726 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
1727 || (tls_type
& GOT_TLS_IE
))
1728 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1729 else if (GOT_TLS_GD_P (tls_type
))
1730 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1731 else if (! GOT_TLS_GDESC_P (tls_type
)
1732 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1733 || h
->root
.type
!= bfd_link_hash_undefweak
)
1735 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
1736 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1737 if (GOT_TLS_GDESC_P (tls_type
))
1738 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1741 h
->got
.offset
= (bfd_vma
) -1;
1743 if (eh
->dyn_relocs
== NULL
)
1746 /* In the shared -Bsymbolic case, discard space allocated for
1747 dynamic pc-relative relocs against symbols which turn out to be
1748 defined in regular objects. For the normal shared case, discard
1749 space for pc-relative relocs that have become local due to symbol
1750 visibility changes. */
1754 /* The only reloc that uses pc_count is R_386_PC32, which will
1755 appear on a call or on something like ".long foo - .". We
1756 want calls to protected symbols to resolve directly to the
1757 function rather than going via the plt. If people want
1758 function pointer comparisons to work as expected then they
1759 should avoid writing assembly like ".long foo - .". */
1760 if (SYMBOL_CALLS_LOCAL (info
, h
))
1762 struct elf_i386_dyn_relocs
**pp
;
1764 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1766 p
->count
-= p
->pc_count
;
1775 /* Also discard relocs on undefined weak syms with non-default
1777 if (eh
->dyn_relocs
!= NULL
1778 && h
->root
.type
== bfd_link_hash_undefweak
)
1780 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1781 eh
->dyn_relocs
= NULL
;
1783 /* Make sure undefined weak symbols are output as a dynamic
1785 else if (h
->dynindx
== -1
1786 && !h
->forced_local
)
1788 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1793 else if (ELIMINATE_COPY_RELOCS
)
1795 /* For the non-shared case, discard space for relocs against
1796 symbols which turn out to need copy relocs or are not
1802 || (htab
->elf
.dynamic_sections_created
1803 && (h
->root
.type
== bfd_link_hash_undefweak
1804 || h
->root
.type
== bfd_link_hash_undefined
))))
1806 /* Make sure this symbol is output as a dynamic symbol.
1807 Undefined weak syms won't yet be marked as dynamic. */
1808 if (h
->dynindx
== -1
1809 && !h
->forced_local
)
1811 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1815 /* If that succeeded, we know we'll be keeping all the
1817 if (h
->dynindx
!= -1)
1821 eh
->dyn_relocs
= NULL
;
1826 /* Finally, allocate space. */
1827 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1829 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1830 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1836 /* Find any dynamic relocs that apply to read-only sections. */
1839 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1841 struct elf_i386_link_hash_entry
*eh
;
1842 struct elf_i386_dyn_relocs
*p
;
1844 if (h
->root
.type
== bfd_link_hash_warning
)
1845 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1847 eh
= (struct elf_i386_link_hash_entry
*) h
;
1848 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1850 asection
*s
= p
->sec
->output_section
;
1852 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1854 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1856 info
->flags
|= DF_TEXTREL
;
1858 /* Not an error, just cut short the traversal. */
1865 /* Set the sizes of the dynamic sections. */
1868 elf_i386_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1869 struct bfd_link_info
*info
)
1871 struct elf_i386_link_hash_table
*htab
;
1877 htab
= elf_i386_hash_table (info
);
1878 dynobj
= htab
->elf
.dynobj
;
1882 if (htab
->elf
.dynamic_sections_created
)
1884 /* Set the contents of the .interp section to the interpreter. */
1885 if (info
->executable
)
1887 s
= bfd_get_section_by_name (dynobj
, ".interp");
1890 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1891 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1895 /* Set up .got offsets for local syms, and space for local dynamic
1897 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1899 bfd_signed_vma
*local_got
;
1900 bfd_signed_vma
*end_local_got
;
1901 char *local_tls_type
;
1902 bfd_vma
*local_tlsdesc_gotent
;
1903 bfd_size_type locsymcount
;
1904 Elf_Internal_Shdr
*symtab_hdr
;
1907 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1910 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1912 struct elf_i386_dyn_relocs
*p
;
1914 for (p
= ((struct elf_i386_dyn_relocs
*)
1915 elf_section_data (s
)->local_dynrel
);
1919 if (!bfd_is_abs_section (p
->sec
)
1920 && bfd_is_abs_section (p
->sec
->output_section
))
1922 /* Input section has been discarded, either because
1923 it is a copy of a linkonce section or due to
1924 linker script /DISCARD/, so we'll be discarding
1927 else if (p
->count
!= 0)
1929 srel
= elf_section_data (p
->sec
)->sreloc
;
1930 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1931 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1932 info
->flags
|= DF_TEXTREL
;
1937 local_got
= elf_local_got_refcounts (ibfd
);
1941 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1942 locsymcount
= symtab_hdr
->sh_info
;
1943 end_local_got
= local_got
+ locsymcount
;
1944 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1945 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
1947 srel
= htab
->srelgot
;
1948 for (; local_got
< end_local_got
;
1949 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
1951 *local_tlsdesc_gotent
= (bfd_vma
) -1;
1954 if (GOT_TLS_GDESC_P (*local_tls_type
))
1956 *local_tlsdesc_gotent
= htab
->sgotplt
->size
1957 - elf_i386_compute_jump_table_size (htab
);
1958 htab
->sgotplt
->size
+= 8;
1959 *local_got
= (bfd_vma
) -2;
1961 if (! GOT_TLS_GDESC_P (*local_tls_type
)
1962 || GOT_TLS_GD_P (*local_tls_type
))
1964 *local_got
= s
->size
;
1966 if (GOT_TLS_GD_P (*local_tls_type
)
1967 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1971 || GOT_TLS_GD_ANY_P (*local_tls_type
)
1972 || (*local_tls_type
& GOT_TLS_IE
))
1974 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1975 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
1976 else if (GOT_TLS_GD_P (*local_tls_type
)
1977 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1978 srel
->size
+= sizeof (Elf32_External_Rel
);
1979 if (GOT_TLS_GDESC_P (*local_tls_type
))
1980 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1984 *local_got
= (bfd_vma
) -1;
1988 if (htab
->tls_ldm_got
.refcount
> 0)
1990 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1992 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
1993 htab
->sgot
->size
+= 8;
1994 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1997 htab
->tls_ldm_got
.offset
= -1;
1999 if (htab
->is_vxworks
)
2001 /* Mark the GOT and PLT symbols as having relocations; they might
2002 not, but we won't know for sure until we build the GOT in
2003 finish_dynamic_symbol. */
2005 htab
->elf
.hgot
->indx
= -2;
2008 htab
->elf
.hplt
->indx
= -2;
2009 if (htab
->splt
->flags
& SEC_CODE
)
2010 htab
->elf
.hplt
->type
= STT_FUNC
;
2014 /* Allocate global sym .plt and .got entries, and space for global
2015 sym dynamic relocs. */
2016 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2018 /* For every jump slot reserved in the sgotplt, reloc_count is
2019 incremented. However, when we reserve space for TLS descriptors,
2020 it's not incremented, so in order to compute the space reserved
2021 for them, it suffices to multiply the reloc count by the jump
2024 htab
->sgotplt_jump_table_size
= htab
->srelplt
->reloc_count
* 4;
2026 /* We now have determined the sizes of the various dynamic sections.
2027 Allocate memory for them. */
2029 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2031 bfd_boolean strip_section
= TRUE
;
2033 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2038 || s
== htab
->sgotplt
2039 || s
== htab
->sdynbss
)
2041 /* Strip this section if we don't need it; see the
2043 /* We'd like to strip these sections if they aren't needed, but if
2044 we've exported dynamic symbols from them we must leave them.
2045 It's too late to tell BFD to get rid of the symbols. */
2047 if (htab
->elf
.hplt
!= NULL
)
2048 strip_section
= FALSE
;
2050 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
2052 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
2055 /* We use the reloc_count field as a counter if we need
2056 to copy relocs into the output file. */
2057 if (s
!= htab
->srelplt
)
2062 /* It's not one of our sections, so don't allocate space. */
2068 /* If we don't need this section, strip it from the
2069 output file. This is mostly to handle .rel.bss and
2070 .rel.plt. We must create both sections in
2071 create_dynamic_sections, because they must be created
2072 before the linker maps input sections to output
2073 sections. The linker does that before
2074 adjust_dynamic_symbol is called, and it is that
2075 function which decides whether anything needs to go
2076 into these sections. */
2078 s
->flags
|= SEC_EXCLUDE
;
2082 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2085 /* Allocate memory for the section contents. We use bfd_zalloc
2086 here in case unused entries are not reclaimed before the
2087 section's contents are written out. This should not happen,
2088 but this way if it does, we get a R_386_NONE reloc instead
2090 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2091 if (s
->contents
== NULL
)
2095 if (htab
->elf
.dynamic_sections_created
)
2097 /* Add some entries to the .dynamic section. We fill in the
2098 values later, in elf_i386_finish_dynamic_sections, but we
2099 must add the entries now so that we get the correct size for
2100 the .dynamic section. The DT_DEBUG entry is filled in by the
2101 dynamic linker and used by the debugger. */
2102 #define add_dynamic_entry(TAG, VAL) \
2103 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2105 if (info
->executable
)
2107 if (!add_dynamic_entry (DT_DEBUG
, 0))
2111 if (htab
->splt
->size
!= 0)
2113 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2114 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2115 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2116 || !add_dynamic_entry (DT_JMPREL
, 0))
2122 if (!add_dynamic_entry (DT_REL
, 0)
2123 || !add_dynamic_entry (DT_RELSZ
, 0)
2124 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2127 /* If any dynamic relocs apply to a read-only section,
2128 then we need a DT_TEXTREL entry. */
2129 if ((info
->flags
& DF_TEXTREL
) == 0)
2130 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2133 if ((info
->flags
& DF_TEXTREL
) != 0)
2135 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2140 #undef add_dynamic_entry
2146 elf_i386_always_size_sections (bfd
*output_bfd
,
2147 struct bfd_link_info
*info
)
2149 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2153 struct elf_link_hash_entry
*tlsbase
;
2155 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2156 "_TLS_MODULE_BASE_",
2157 FALSE
, FALSE
, FALSE
);
2159 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2161 struct bfd_link_hash_entry
*bh
= NULL
;
2162 const struct elf_backend_data
*bed
2163 = get_elf_backend_data (output_bfd
);
2165 if (!(_bfd_generic_link_add_one_symbol
2166 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2167 tls_sec
, 0, NULL
, FALSE
,
2168 bed
->collect
, &bh
)))
2170 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2171 tlsbase
->def_regular
= 1;
2172 tlsbase
->other
= STV_HIDDEN
;
2173 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2180 /* Set the correct type for an x86 ELF section. We do this by the
2181 section name, which is a hack, but ought to work. */
2184 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2185 Elf_Internal_Shdr
*hdr
,
2188 register const char *name
;
2190 name
= bfd_get_section_name (abfd
, sec
);
2192 /* This is an ugly, but unfortunately necessary hack that is
2193 needed when producing EFI binaries on x86. It tells
2194 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2195 containing ELF relocation info. We need this hack in order to
2196 be able to generate ELF binaries that can be translated into
2197 EFI applications (which are essentially COFF objects). Those
2198 files contain a COFF ".reloc" section inside an ELFNN object,
2199 which would normally cause BFD to segfault because it would
2200 attempt to interpret this section as containing relocation
2201 entries for section "oc". With this hack enabled, ".reloc"
2202 will be treated as a normal data section, which will avoid the
2203 segfault. However, you won't be able to create an ELFNN binary
2204 with a section named "oc" that needs relocations, but that's
2205 the kind of ugly side-effects you get when detecting section
2206 types based on their names... In practice, this limitation is
2207 unlikely to bite. */
2208 if (strcmp (name
, ".reloc") == 0)
2209 hdr
->sh_type
= SHT_PROGBITS
;
2214 /* Return the base VMA address which should be subtracted from real addresses
2215 when resolving @dtpoff relocation.
2216 This is PT_TLS segment p_vaddr. */
2219 dtpoff_base (struct bfd_link_info
*info
)
2221 /* If tls_sec is NULL, we should have signalled an error already. */
2222 if (elf_hash_table (info
)->tls_sec
== NULL
)
2224 return elf_hash_table (info
)->tls_sec
->vma
;
2227 /* Return the relocation value for @tpoff relocation
2228 if STT_TLS virtual address is ADDRESS. */
2231 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2233 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2235 /* If tls_sec is NULL, we should have signalled an error already. */
2236 if (htab
->tls_sec
== NULL
)
2238 return htab
->tls_size
+ htab
->tls_sec
->vma
- address
;
2241 /* Relocate an i386 ELF section. */
2244 elf_i386_relocate_section (bfd
*output_bfd
,
2245 struct bfd_link_info
*info
,
2247 asection
*input_section
,
2249 Elf_Internal_Rela
*relocs
,
2250 Elf_Internal_Sym
*local_syms
,
2251 asection
**local_sections
)
2253 struct elf_i386_link_hash_table
*htab
;
2254 Elf_Internal_Shdr
*symtab_hdr
;
2255 struct elf_link_hash_entry
**sym_hashes
;
2256 bfd_vma
*local_got_offsets
;
2257 bfd_vma
*local_tlsdesc_gotents
;
2258 Elf_Internal_Rela
*rel
;
2259 Elf_Internal_Rela
*relend
;
2261 htab
= elf_i386_hash_table (info
);
2262 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2263 sym_hashes
= elf_sym_hashes (input_bfd
);
2264 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2265 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2268 relend
= relocs
+ input_section
->reloc_count
;
2269 for (; rel
< relend
; rel
++)
2271 unsigned int r_type
;
2272 reloc_howto_type
*howto
;
2273 unsigned long r_symndx
;
2274 struct elf_link_hash_entry
*h
;
2275 Elf_Internal_Sym
*sym
;
2277 bfd_vma off
, offplt
;
2279 bfd_boolean unresolved_reloc
;
2280 bfd_reloc_status_type r
;
2284 r_type
= ELF32_R_TYPE (rel
->r_info
);
2285 if (r_type
== R_386_GNU_VTINHERIT
2286 || r_type
== R_386_GNU_VTENTRY
)
2289 if ((indx
= r_type
) >= R_386_standard
2290 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2291 >= R_386_ext
- R_386_standard
)
2292 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2293 >= R_386_tls
- R_386_ext
))
2295 (*_bfd_error_handler
)
2296 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2297 input_bfd
, input_section
, r_type
);
2298 bfd_set_error (bfd_error_bad_value
);
2301 howto
= elf_howto_table
+ indx
;
2303 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2305 if (info
->relocatable
)
2310 /* This is a relocatable link. We don't have to change
2311 anything, unless the reloc is against a section symbol,
2312 in which case we have to adjust according to where the
2313 section symbol winds up in the output section. */
2314 if (r_symndx
>= symtab_hdr
->sh_info
)
2317 sym
= local_syms
+ r_symndx
;
2318 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2321 sec
= local_sections
[r_symndx
];
2322 val
= sec
->output_offset
;
2326 where
= contents
+ rel
->r_offset
;
2327 switch (howto
->size
)
2329 /* FIXME: overflow checks. */
2331 val
+= bfd_get_8 (input_bfd
, where
);
2332 bfd_put_8 (input_bfd
, val
, where
);
2335 val
+= bfd_get_16 (input_bfd
, where
);
2336 bfd_put_16 (input_bfd
, val
, where
);
2339 val
+= bfd_get_32 (input_bfd
, where
);
2340 bfd_put_32 (input_bfd
, val
, where
);
2348 /* This is a final link. */
2352 unresolved_reloc
= FALSE
;
2353 if (r_symndx
< symtab_hdr
->sh_info
)
2355 sym
= local_syms
+ r_symndx
;
2356 sec
= local_sections
[r_symndx
];
2357 relocation
= (sec
->output_section
->vma
2358 + sec
->output_offset
2360 if ((sec
->flags
& SEC_MERGE
)
2361 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2365 bfd_byte
*where
= contents
+ rel
->r_offset
;
2367 switch (howto
->size
)
2370 addend
= bfd_get_8 (input_bfd
, where
);
2371 if (howto
->pc_relative
)
2373 addend
= (addend
^ 0x80) - 0x80;
2378 addend
= bfd_get_16 (input_bfd
, where
);
2379 if (howto
->pc_relative
)
2381 addend
= (addend
^ 0x8000) - 0x8000;
2386 addend
= bfd_get_32 (input_bfd
, where
);
2387 if (howto
->pc_relative
)
2389 addend
= (addend
^ 0x80000000) - 0x80000000;
2398 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2399 addend
-= relocation
;
2400 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2402 switch (howto
->size
)
2405 /* FIXME: overflow checks. */
2406 if (howto
->pc_relative
)
2408 bfd_put_8 (input_bfd
, addend
, where
);
2411 if (howto
->pc_relative
)
2413 bfd_put_16 (input_bfd
, addend
, where
);
2416 if (howto
->pc_relative
)
2418 bfd_put_32 (input_bfd
, addend
, where
);
2427 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2428 r_symndx
, symtab_hdr
, sym_hashes
,
2430 unresolved_reloc
, warned
);
2435 /* r_symndx will be zero only for relocs against symbols from
2436 removed linkonce sections, or sections discarded by a linker
2437 script. For these relocs, we just want the section contents
2438 zeroed. Avoid any special processing in the switch below. */
2439 r_type
= R_386_NONE
;
2442 if (howto
->pc_relative
)
2443 relocation
= (input_section
->output_section
->vma
2444 + input_section
->output_offset
2451 /* Relocation is to the entry for this symbol in the global
2453 if (htab
->sgot
== NULL
)
2460 off
= h
->got
.offset
;
2461 dyn
= htab
->elf
.dynamic_sections_created
;
2462 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2464 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2465 || (ELF_ST_VISIBILITY (h
->other
)
2466 && h
->root
.type
== bfd_link_hash_undefweak
))
2468 /* This is actually a static link, or it is a
2469 -Bsymbolic link and the symbol is defined
2470 locally, or the symbol was forced to be local
2471 because of a version file. We must initialize
2472 this entry in the global offset table. Since the
2473 offset must always be a multiple of 4, we use the
2474 least significant bit to record whether we have
2475 initialized it already.
2477 When doing a dynamic link, we create a .rel.got
2478 relocation entry to initialize the value. This
2479 is done in the finish_dynamic_symbol routine. */
2484 bfd_put_32 (output_bfd
, relocation
,
2485 htab
->sgot
->contents
+ off
);
2490 unresolved_reloc
= FALSE
;
2494 if (local_got_offsets
== NULL
)
2497 off
= local_got_offsets
[r_symndx
];
2499 /* The offset must always be a multiple of 4. We use
2500 the least significant bit to record whether we have
2501 already generated the necessary reloc. */
2506 bfd_put_32 (output_bfd
, relocation
,
2507 htab
->sgot
->contents
+ off
);
2512 Elf_Internal_Rela outrel
;
2519 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2520 + htab
->sgot
->output_offset
2522 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2524 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2525 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2528 local_got_offsets
[r_symndx
] |= 1;
2532 if (off
>= (bfd_vma
) -2)
2535 relocation
= htab
->sgot
->output_section
->vma
2536 + htab
->sgot
->output_offset
+ off
2537 - htab
->sgotplt
->output_section
->vma
2538 - htab
->sgotplt
->output_offset
;
2542 /* Relocation is relative to the start of the global offset
2545 /* Check to make sure it isn't a protected function symbol
2546 for shared library since it may not be local when used
2547 as function address. */
2549 && !info
->executable
2552 && h
->type
== STT_FUNC
2553 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
2555 (*_bfd_error_handler
)
2556 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2557 input_bfd
, h
->root
.root
.string
);
2558 bfd_set_error (bfd_error_bad_value
);
2562 /* Note that sgot is not involved in this
2563 calculation. We always want the start of .got.plt. If we
2564 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2565 permitted by the ABI, we might have to change this
2567 relocation
-= htab
->sgotplt
->output_section
->vma
2568 + htab
->sgotplt
->output_offset
;
2572 /* Use global offset table as symbol value. */
2573 relocation
= htab
->sgotplt
->output_section
->vma
2574 + htab
->sgotplt
->output_offset
;
2575 unresolved_reloc
= FALSE
;
2579 /* Relocation is to the entry for this symbol in the
2580 procedure linkage table. */
2582 /* Resolve a PLT32 reloc against a local symbol directly,
2583 without using the procedure linkage table. */
2587 if (h
->plt
.offset
== (bfd_vma
) -1
2588 || htab
->splt
== NULL
)
2590 /* We didn't make a PLT entry for this symbol. This
2591 happens when statically linking PIC code, or when
2592 using -Bsymbolic. */
2596 relocation
= (htab
->splt
->output_section
->vma
2597 + htab
->splt
->output_offset
2599 unresolved_reloc
= FALSE
;
2604 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2609 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2610 || h
->root
.type
!= bfd_link_hash_undefweak
)
2611 && (r_type
!= R_386_PC32
2612 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2613 || (ELIMINATE_COPY_RELOCS
2620 || h
->root
.type
== bfd_link_hash_undefweak
2621 || h
->root
.type
== bfd_link_hash_undefined
)))
2623 Elf_Internal_Rela outrel
;
2625 bfd_boolean skip
, relocate
;
2628 /* When generating a shared object, these relocations
2629 are copied into the output file to be resolved at run
2636 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2638 if (outrel
.r_offset
== (bfd_vma
) -1)
2640 else if (outrel
.r_offset
== (bfd_vma
) -2)
2641 skip
= TRUE
, relocate
= TRUE
;
2642 outrel
.r_offset
+= (input_section
->output_section
->vma
2643 + input_section
->output_offset
);
2646 memset (&outrel
, 0, sizeof outrel
);
2649 && (r_type
== R_386_PC32
2652 || !h
->def_regular
))
2653 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2656 /* This symbol is local, or marked to become local. */
2658 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2661 sreloc
= elf_section_data (input_section
)->sreloc
;
2665 loc
= sreloc
->contents
;
2666 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2667 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2669 /* If this reloc is against an external symbol, we do
2670 not want to fiddle with the addend. Otherwise, we
2671 need to include the symbol value so that it becomes
2672 an addend for the dynamic reloc. */
2681 Elf_Internal_Rela outrel
;
2685 outrel
.r_offset
= rel
->r_offset
2686 + input_section
->output_section
->vma
2687 + input_section
->output_offset
;
2688 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2689 sreloc
= elf_section_data (input_section
)->sreloc
;
2692 loc
= sreloc
->contents
;
2693 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2694 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2699 case R_386_TLS_GOTDESC
:
2700 case R_386_TLS_DESC_CALL
:
2701 case R_386_TLS_IE_32
:
2702 case R_386_TLS_GOTIE
:
2703 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2704 tls_type
= GOT_UNKNOWN
;
2705 if (h
== NULL
&& local_got_offsets
)
2706 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2709 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2710 if (!info
->shared
&& h
->dynindx
== -1 && (tls_type
& GOT_TLS_IE
))
2711 r_type
= R_386_TLS_LE_32
;
2713 if (tls_type
== GOT_TLS_IE
)
2714 tls_type
= GOT_TLS_IE_NEG
;
2715 if (r_type
== R_386_TLS_GD
2716 || r_type
== R_386_TLS_GOTDESC
2717 || r_type
== R_386_TLS_DESC_CALL
)
2719 if (tls_type
== GOT_TLS_IE_POS
)
2720 r_type
= R_386_TLS_GOTIE
;
2721 else if (tls_type
& GOT_TLS_IE
)
2722 r_type
= R_386_TLS_IE_32
;
2725 if (r_type
== R_386_TLS_LE_32
)
2727 BFD_ASSERT (! unresolved_reloc
);
2728 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2730 unsigned int val
, type
;
2733 /* GD->LE transition. */
2734 BFD_ASSERT (rel
->r_offset
>= 2);
2735 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2736 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2737 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
2738 BFD_ASSERT (bfd_get_8 (input_bfd
,
2739 contents
+ rel
->r_offset
+ 4)
2741 BFD_ASSERT (rel
+ 1 < relend
);
2742 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2743 roff
= rel
->r_offset
+ 5;
2744 val
= bfd_get_8 (input_bfd
,
2745 contents
+ rel
->r_offset
- 1);
2748 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2750 movl %gs:0, %eax; subl $foo@tpoff, %eax
2751 (6 byte form of subl). */
2752 BFD_ASSERT (rel
->r_offset
>= 3);
2753 BFD_ASSERT (bfd_get_8 (input_bfd
,
2754 contents
+ rel
->r_offset
- 3)
2756 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2757 memcpy (contents
+ rel
->r_offset
- 3,
2758 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2762 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2763 if (rel
->r_offset
+ 10 <= input_section
->size
2764 && bfd_get_8 (input_bfd
,
2765 contents
+ rel
->r_offset
+ 9) == 0x90)
2767 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2769 movl %gs:0, %eax; subl $foo@tpoff, %eax
2770 (6 byte form of subl). */
2771 memcpy (contents
+ rel
->r_offset
- 2,
2772 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2773 roff
= rel
->r_offset
+ 6;
2777 /* leal foo(%reg), %eax; call ___tls_get_addr
2779 movl %gs:0, %eax; subl $foo@tpoff, %eax
2780 (5 byte form of subl). */
2781 memcpy (contents
+ rel
->r_offset
- 2,
2782 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2785 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2787 /* Skip R_386_PLT32. */
2791 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
2793 /* GDesc -> LE transition.
2794 It's originally something like:
2795 leal x@tlsdesc(%ebx), %eax
2799 Registers other than %eax may be set up here. */
2801 unsigned int val
, type
;
2804 /* First, make sure it's a leal adding ebx to a
2805 32-bit offset into any register, although it's
2806 probably almost always going to be eax. */
2807 roff
= rel
->r_offset
;
2808 BFD_ASSERT (roff
>= 2);
2809 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
2810 BFD_ASSERT (type
== 0x8d);
2811 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
2812 BFD_ASSERT ((val
& 0xc7) == 0x83);
2813 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
2815 /* Now modify the instruction as appropriate. */
2816 /* aoliva FIXME: remove the above and xor the byte
2818 bfd_put_8 (output_bfd
, val
^ 0x86,
2819 contents
+ roff
- 1);
2820 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2824 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
2826 /* GDesc -> LE transition.
2832 unsigned int val
, type
;
2835 /* First, make sure it's a call *(%eax). */
2836 roff
= rel
->r_offset
;
2837 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
2838 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
2839 BFD_ASSERT (type
== 0xff);
2840 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
2841 BFD_ASSERT (val
== 0x10);
2843 /* Now modify the instruction as appropriate. */
2844 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
2845 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
2848 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
2850 unsigned int val
, type
;
2852 /* IE->LE transition:
2853 Originally it can be one of:
2861 BFD_ASSERT (rel
->r_offset
>= 1);
2862 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2863 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2866 /* movl foo, %eax. */
2867 bfd_put_8 (output_bfd
, 0xb8,
2868 contents
+ rel
->r_offset
- 1);
2872 BFD_ASSERT (rel
->r_offset
>= 2);
2873 type
= bfd_get_8 (input_bfd
,
2874 contents
+ rel
->r_offset
- 2);
2879 BFD_ASSERT ((val
& 0xc7) == 0x05);
2880 bfd_put_8 (output_bfd
, 0xc7,
2881 contents
+ rel
->r_offset
- 2);
2882 bfd_put_8 (output_bfd
,
2883 0xc0 | ((val
>> 3) & 7),
2884 contents
+ rel
->r_offset
- 1);
2888 BFD_ASSERT ((val
& 0xc7) == 0x05);
2889 bfd_put_8 (output_bfd
, 0x81,
2890 contents
+ rel
->r_offset
- 2);
2891 bfd_put_8 (output_bfd
,
2892 0xc0 | ((val
>> 3) & 7),
2893 contents
+ rel
->r_offset
- 1);
2900 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2901 contents
+ rel
->r_offset
);
2906 unsigned int val
, type
;
2908 /* {IE_32,GOTIE}->LE transition:
2909 Originally it can be one of:
2910 subl foo(%reg1), %reg2
2911 movl foo(%reg1), %reg2
2912 addl foo(%reg1), %reg2
2915 movl $foo, %reg2 (6 byte form)
2916 addl $foo, %reg2. */
2917 BFD_ASSERT (rel
->r_offset
>= 2);
2918 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2919 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2920 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2921 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2925 bfd_put_8 (output_bfd
, 0xc7,
2926 contents
+ rel
->r_offset
- 2);
2927 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2928 contents
+ rel
->r_offset
- 1);
2930 else if (type
== 0x2b)
2933 bfd_put_8 (output_bfd
, 0x81,
2934 contents
+ rel
->r_offset
- 2);
2935 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2936 contents
+ rel
->r_offset
- 1);
2938 else if (type
== 0x03)
2941 bfd_put_8 (output_bfd
, 0x81,
2942 contents
+ rel
->r_offset
- 2);
2943 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2944 contents
+ rel
->r_offset
- 1);
2948 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
2949 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2950 contents
+ rel
->r_offset
);
2952 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2953 contents
+ rel
->r_offset
);
2958 if (htab
->sgot
== NULL
)
2963 off
= h
->got
.offset
;
2964 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
2968 if (local_got_offsets
== NULL
)
2971 off
= local_got_offsets
[r_symndx
];
2972 offplt
= local_tlsdesc_gotents
[r_symndx
];
2979 Elf_Internal_Rela outrel
;
2984 if (htab
->srelgot
== NULL
)
2987 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2989 if (GOT_TLS_GDESC_P (tls_type
))
2991 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
2992 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
2993 <= htab
->sgotplt
->size
);
2994 outrel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2995 + htab
->sgotplt
->output_offset
2997 + htab
->sgotplt_jump_table_size
);
2998 sreloc
= htab
->srelplt
;
2999 loc
= sreloc
->contents
;
3000 loc
+= sreloc
->reloc_count
++
3001 * sizeof (Elf32_External_Rel
);
3002 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3003 <= sreloc
->contents
+ sreloc
->size
);
3004 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3007 BFD_ASSERT (! unresolved_reloc
);
3008 bfd_put_32 (output_bfd
,
3009 relocation
- dtpoff_base (info
),
3010 htab
->sgotplt
->contents
+ offplt
3011 + htab
->sgotplt_jump_table_size
+ 4);
3015 bfd_put_32 (output_bfd
, 0,
3016 htab
->sgotplt
->contents
+ offplt
3017 + htab
->sgotplt_jump_table_size
+ 4);
3021 sreloc
= htab
->srelgot
;
3023 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3024 + htab
->sgot
->output_offset
+ off
);
3026 if (GOT_TLS_GD_P (tls_type
))
3027 dr_type
= R_386_TLS_DTPMOD32
;
3028 else if (GOT_TLS_GDESC_P (tls_type
))
3030 else if (tls_type
== GOT_TLS_IE_POS
)
3031 dr_type
= R_386_TLS_TPOFF
;
3033 dr_type
= R_386_TLS_TPOFF32
;
3035 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3036 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
3037 htab
->sgot
->contents
+ off
);
3038 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3039 bfd_put_32 (output_bfd
, dtpoff_base (info
) - relocation
,
3040 htab
->sgot
->contents
+ off
);
3041 else if (dr_type
!= R_386_TLS_DESC
)
3042 bfd_put_32 (output_bfd
, 0,
3043 htab
->sgot
->contents
+ off
);
3044 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3046 loc
= sreloc
->contents
;
3047 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3048 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3049 <= sreloc
->contents
+ sreloc
->size
);
3050 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3052 if (GOT_TLS_GD_P (tls_type
))
3056 BFD_ASSERT (! unresolved_reloc
);
3057 bfd_put_32 (output_bfd
,
3058 relocation
- dtpoff_base (info
),
3059 htab
->sgot
->contents
+ off
+ 4);
3063 bfd_put_32 (output_bfd
, 0,
3064 htab
->sgot
->contents
+ off
+ 4);
3065 outrel
.r_info
= ELF32_R_INFO (indx
,
3066 R_386_TLS_DTPOFF32
);
3067 outrel
.r_offset
+= 4;
3068 sreloc
->reloc_count
++;
3069 loc
+= sizeof (Elf32_External_Rel
);
3070 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3071 <= sreloc
->contents
+ sreloc
->size
);
3072 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3075 else if (tls_type
== GOT_TLS_IE_BOTH
)
3077 bfd_put_32 (output_bfd
,
3078 indx
== 0 ? relocation
- dtpoff_base (info
) : 0,
3079 htab
->sgot
->contents
+ off
+ 4);
3080 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3081 outrel
.r_offset
+= 4;
3082 sreloc
->reloc_count
++;
3083 loc
+= sizeof (Elf32_External_Rel
);
3084 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3091 local_got_offsets
[r_symndx
] |= 1;
3094 if (off
>= (bfd_vma
) -2
3095 && ! GOT_TLS_GDESC_P (tls_type
))
3097 if (r_type
== R_386_TLS_GOTDESC
3098 || r_type
== R_386_TLS_DESC_CALL
)
3100 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3101 unresolved_reloc
= FALSE
;
3103 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3105 bfd_vma g_o_t
= htab
->sgotplt
->output_section
->vma
3106 + htab
->sgotplt
->output_offset
;
3107 relocation
= htab
->sgot
->output_section
->vma
3108 + htab
->sgot
->output_offset
+ off
- g_o_t
;
3109 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3110 && tls_type
== GOT_TLS_IE_BOTH
)
3112 if (r_type
== R_386_TLS_IE
)
3113 relocation
+= g_o_t
;
3114 unresolved_reloc
= FALSE
;
3116 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3118 unsigned int val
, type
;
3121 /* GD->IE transition. */
3122 BFD_ASSERT (rel
->r_offset
>= 2);
3123 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3124 BFD_ASSERT (type
== 0x8d || type
== 0x04);
3125 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3126 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3128 BFD_ASSERT (rel
+ 1 < relend
);
3129 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3130 roff
= rel
->r_offset
- 3;
3131 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3134 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3136 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3137 BFD_ASSERT (rel
->r_offset
>= 3);
3138 BFD_ASSERT (bfd_get_8 (input_bfd
,
3139 contents
+ rel
->r_offset
- 3)
3141 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
3146 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3148 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3149 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->size
);
3150 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3151 BFD_ASSERT (bfd_get_8 (input_bfd
,
3152 contents
+ rel
->r_offset
+ 9)
3154 roff
= rel
->r_offset
- 2;
3156 memcpy (contents
+ roff
,
3157 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3158 contents
[roff
+ 7] = 0x80 | (val
& 7);
3159 /* If foo is used only with foo@gotntpoff(%reg) and
3160 foo@indntpoff, but not with foo@gottpoff(%reg), change
3161 subl $foo@gottpoff(%reg), %eax
3163 addl $foo@gotntpoff(%reg), %eax. */
3164 if (r_type
== R_386_TLS_GOTIE
)
3166 contents
[roff
+ 6] = 0x03;
3167 if (tls_type
== GOT_TLS_IE_BOTH
)
3170 bfd_put_32 (output_bfd
,
3171 htab
->sgot
->output_section
->vma
3172 + htab
->sgot
->output_offset
+ off
3173 - htab
->sgotplt
->output_section
->vma
3174 - htab
->sgotplt
->output_offset
,
3175 contents
+ roff
+ 8);
3176 /* Skip R_386_PLT32. */
3180 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3182 /* GDesc -> IE transition.
3183 It's originally something like:
3184 leal x@tlsdesc(%ebx), %eax
3187 movl x@gotntpoff(%ebx), %eax # before nop; nop
3189 movl x@gottpoff(%ebx), %eax # before negl %eax
3191 Registers other than %eax may be set up here. */
3193 unsigned int val
, type
;
3196 /* First, make sure it's a leal adding ebx to a 32-bit
3197 offset into any register, although it's probably
3198 almost always going to be eax. */
3199 roff
= rel
->r_offset
;
3200 BFD_ASSERT (roff
>= 2);
3201 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3202 BFD_ASSERT (type
== 0x8d);
3203 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3204 BFD_ASSERT ((val
& 0xc7) == 0x83);
3205 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
3207 /* Now modify the instruction as appropriate. */
3208 /* To turn a leal into a movl in the form we use it, it
3209 suffices to change the first byte from 0x8d to 0x8b.
3210 aoliva FIXME: should we decide to keep the leal, all
3211 we have to do is remove the statement below, and
3212 adjust the relaxation of R_386_TLS_DESC_CALL. */
3213 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3215 if (tls_type
== GOT_TLS_IE_BOTH
)
3218 bfd_put_32 (output_bfd
,
3219 htab
->sgot
->output_section
->vma
3220 + htab
->sgot
->output_offset
+ off
3221 - htab
->sgotplt
->output_section
->vma
3222 - htab
->sgotplt
->output_offset
,
3226 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3228 /* GDesc -> IE transition.
3236 depending on how we transformed the TLS_GOTDESC above.
3239 unsigned int val
, type
;
3242 /* First, make sure it's a call *(%eax). */
3243 roff
= rel
->r_offset
;
3244 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
3245 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
3246 BFD_ASSERT (type
== 0xff);
3247 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
3248 BFD_ASSERT (val
== 0x10);
3250 /* Now modify the instruction as appropriate. */
3251 if (tls_type
!= GOT_TLS_IE_NEG
)
3254 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
3255 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3260 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
3261 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
3275 /* LD->LE transition:
3277 leal foo(%reg), %eax; call ___tls_get_addr.
3279 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3280 BFD_ASSERT (rel
->r_offset
>= 2);
3281 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
3283 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3284 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3285 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3286 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3288 BFD_ASSERT (rel
+ 1 < relend
);
3289 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3290 memcpy (contents
+ rel
->r_offset
- 2,
3291 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3292 /* Skip R_386_PLT32. */
3297 if (htab
->sgot
== NULL
)
3300 off
= htab
->tls_ldm_got
.offset
;
3305 Elf_Internal_Rela outrel
;
3308 if (htab
->srelgot
== NULL
)
3311 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3312 + htab
->sgot
->output_offset
+ off
);
3314 bfd_put_32 (output_bfd
, 0,
3315 htab
->sgot
->contents
+ off
);
3316 bfd_put_32 (output_bfd
, 0,
3317 htab
->sgot
->contents
+ off
+ 4);
3318 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
3319 loc
= htab
->srelgot
->contents
;
3320 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3321 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3322 htab
->tls_ldm_got
.offset
|= 1;
3324 relocation
= htab
->sgot
->output_section
->vma
3325 + htab
->sgot
->output_offset
+ off
3326 - htab
->sgotplt
->output_section
->vma
3327 - htab
->sgotplt
->output_offset
;
3328 unresolved_reloc
= FALSE
;
3331 case R_386_TLS_LDO_32
:
3332 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
3333 relocation
-= dtpoff_base (info
);
3335 /* When converting LDO to LE, we must negate. */
3336 relocation
= -tpoff (info
, relocation
);
3339 case R_386_TLS_LE_32
:
3343 Elf_Internal_Rela outrel
;
3348 outrel
.r_offset
= rel
->r_offset
3349 + input_section
->output_section
->vma
3350 + input_section
->output_offset
;
3351 if (h
!= NULL
&& h
->dynindx
!= -1)
3355 if (r_type
== R_386_TLS_LE_32
)
3356 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
3358 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3359 sreloc
= elf_section_data (input_section
)->sreloc
;
3362 loc
= sreloc
->contents
;
3363 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3364 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3367 else if (r_type
== R_386_TLS_LE_32
)
3368 relocation
= dtpoff_base (info
) - relocation
;
3370 relocation
-= dtpoff_base (info
);
3372 else if (r_type
== R_386_TLS_LE_32
)
3373 relocation
= tpoff (info
, relocation
);
3375 relocation
= -tpoff (info
, relocation
);
3382 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3383 because such sections are not SEC_ALLOC and thus ld.so will
3384 not process them. */
3385 if (unresolved_reloc
3386 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3389 (*_bfd_error_handler
)
3390 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3393 (long) rel
->r_offset
,
3395 h
->root
.root
.string
);
3399 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3400 contents
, rel
->r_offset
,
3403 if (r
!= bfd_reloc_ok
)
3408 name
= h
->root
.root
.string
;
3411 name
= bfd_elf_string_from_elf_section (input_bfd
,
3412 symtab_hdr
->sh_link
,
3417 name
= bfd_section_name (input_bfd
, sec
);
3420 if (r
== bfd_reloc_overflow
)
3422 if (! ((*info
->callbacks
->reloc_overflow
)
3423 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3424 (bfd_vma
) 0, input_bfd
, input_section
,
3430 (*_bfd_error_handler
)
3431 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3432 input_bfd
, input_section
,
3433 (long) rel
->r_offset
, name
, (int) r
);
3442 /* Finish up dynamic symbol handling. We set the contents of various
3443 dynamic sections here. */
3446 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
3447 struct bfd_link_info
*info
,
3448 struct elf_link_hash_entry
*h
,
3449 Elf_Internal_Sym
*sym
)
3451 struct elf_i386_link_hash_table
*htab
;
3453 htab
= elf_i386_hash_table (info
);
3455 if (h
->plt
.offset
!= (bfd_vma
) -1)
3459 Elf_Internal_Rela rel
;
3462 /* This symbol has an entry in the procedure linkage table. Set
3465 if (h
->dynindx
== -1
3466 || htab
->splt
== NULL
3467 || htab
->sgotplt
== NULL
3468 || htab
->srelplt
== NULL
)
3471 /* Get the index in the procedure linkage table which
3472 corresponds to this symbol. This is the index of this symbol
3473 in all the symbols for which we are making plt entries. The
3474 first entry in the procedure linkage table is reserved. */
3475 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3477 /* Get the offset into the .got table of the entry that
3478 corresponds to this function. Each .got entry is 4 bytes.
3479 The first three are reserved. */
3480 got_offset
= (plt_index
+ 3) * 4;
3482 /* Fill in the entry in the procedure linkage table. */
3485 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
3487 bfd_put_32 (output_bfd
,
3488 (htab
->sgotplt
->output_section
->vma
3489 + htab
->sgotplt
->output_offset
3491 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3493 if (htab
->is_vxworks
)
3495 int s
, k
, reloc_index
;
3497 /* Create the R_386_32 relocation referencing the GOT
3498 for this PLT entry. */
3500 /* S: Current slot number (zero-based). */
3501 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
3502 /* K: Number of relocations for PLTResolve. */
3504 k
= PLTRESOLVE_RELOCS_SHLIB
;
3506 k
= PLTRESOLVE_RELOCS
;
3507 /* Skip the PLTresolve relocations, and the relocations for
3508 the other PLT slots. */
3509 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
3510 loc
= (htab
->srelplt2
->contents
+ reloc_index
3511 * sizeof (Elf32_External_Rel
));
3513 rel
.r_offset
= (htab
->splt
->output_section
->vma
3514 + htab
->splt
->output_offset
3515 + h
->plt
.offset
+ 2),
3516 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3517 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3519 /* Create the R_386_32 relocation referencing the beginning of
3520 the PLT for this GOT entry. */
3521 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3522 + htab
->sgotplt
->output_offset
3524 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
3525 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3526 loc
+ sizeof (Elf32_External_Rel
));
3531 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
3533 bfd_put_32 (output_bfd
, got_offset
,
3534 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3537 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
3538 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
3539 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
3540 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
3542 /* Fill in the entry in the global offset table. */
3543 bfd_put_32 (output_bfd
,
3544 (htab
->splt
->output_section
->vma
3545 + htab
->splt
->output_offset
3548 htab
->sgotplt
->contents
+ got_offset
);
3550 /* Fill in the entry in the .rel.plt section. */
3551 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3552 + htab
->sgotplt
->output_offset
3554 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
3555 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3556 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3558 if (!h
->def_regular
)
3560 /* Mark the symbol as undefined, rather than as defined in
3561 the .plt section. Leave the value if there were any
3562 relocations where pointer equality matters (this is a clue
3563 for the dynamic linker, to make function pointer
3564 comparisons work between an application and shared
3565 library), otherwise set it to zero. If a function is only
3566 called from a binary, there is no need to slow down
3567 shared libraries because of that. */
3568 sym
->st_shndx
= SHN_UNDEF
;
3569 if (!h
->pointer_equality_needed
)
3574 if (h
->got
.offset
!= (bfd_vma
) -1
3575 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
3576 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
3578 Elf_Internal_Rela rel
;
3581 /* This symbol has an entry in the global offset table. Set it
3584 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
3587 rel
.r_offset
= (htab
->sgot
->output_section
->vma
3588 + htab
->sgot
->output_offset
3589 + (h
->got
.offset
& ~(bfd_vma
) 1));
3591 /* If this is a static link, or it is a -Bsymbolic link and the
3592 symbol is defined locally or was forced to be local because
3593 of a version file, we just want to emit a RELATIVE reloc.
3594 The entry in the global offset table will already have been
3595 initialized in the relocate_section function. */
3597 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3599 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3600 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3604 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3605 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
3606 htab
->sgot
->contents
+ h
->got
.offset
);
3607 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
3610 loc
= htab
->srelgot
->contents
;
3611 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3612 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3617 Elf_Internal_Rela rel
;
3620 /* This symbol needs a copy reloc. Set it up. */
3622 if (h
->dynindx
== -1
3623 || (h
->root
.type
!= bfd_link_hash_defined
3624 && h
->root
.type
!= bfd_link_hash_defweak
)
3625 || htab
->srelbss
== NULL
)
3628 rel
.r_offset
= (h
->root
.u
.def
.value
3629 + h
->root
.u
.def
.section
->output_section
->vma
3630 + h
->root
.u
.def
.section
->output_offset
);
3631 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
3632 loc
= htab
->srelbss
->contents
;
3633 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3634 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3637 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3638 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3639 is relative to the ".got" section. */
3640 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3641 || (strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3642 && !htab
->is_vxworks
))
3643 sym
->st_shndx
= SHN_ABS
;
3648 /* Used to decide how to sort relocs in an optimal manner for the
3649 dynamic linker, before writing them out. */
3651 static enum elf_reloc_type_class
3652 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
3654 switch (ELF32_R_TYPE (rela
->r_info
))
3656 case R_386_RELATIVE
:
3657 return reloc_class_relative
;
3658 case R_386_JUMP_SLOT
:
3659 return reloc_class_plt
;
3661 return reloc_class_copy
;
3663 return reloc_class_normal
;
3667 /* Finish up the dynamic sections. */
3670 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
3671 struct bfd_link_info
*info
)
3673 struct elf_i386_link_hash_table
*htab
;
3677 htab
= elf_i386_hash_table (info
);
3678 dynobj
= htab
->elf
.dynobj
;
3679 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3681 if (htab
->elf
.dynamic_sections_created
)
3683 Elf32_External_Dyn
*dyncon
, *dynconend
;
3685 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3688 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3689 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3690 for (; dyncon
< dynconend
; dyncon
++)
3692 Elf_Internal_Dyn dyn
;
3695 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3704 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3709 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3714 dyn
.d_un
.d_val
= s
->size
;
3718 /* My reading of the SVR4 ABI indicates that the
3719 procedure linkage table relocs (DT_JMPREL) should be
3720 included in the overall relocs (DT_REL). This is
3721 what Solaris does. However, UnixWare can not handle
3722 that case. Therefore, we override the DT_RELSZ entry
3723 here to make it not include the JMPREL relocs. */
3727 dyn
.d_un
.d_val
-= s
->size
;
3731 /* We may not be using the standard ELF linker script.
3732 If .rel.plt is the first .rel section, we adjust
3733 DT_REL to not include it. */
3737 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
3739 dyn
.d_un
.d_ptr
+= s
->size
;
3743 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3746 /* Fill in the first entry in the procedure linkage table. */
3747 if (htab
->splt
&& htab
->splt
->size
> 0)
3751 memcpy (htab
->splt
->contents
, elf_i386_pic_plt0_entry
,
3752 sizeof (elf_i386_pic_plt0_entry
));
3753 memset (htab
->splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
3754 htab
->plt0_pad_byte
,
3755 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
3759 memcpy (htab
->splt
->contents
, elf_i386_plt0_entry
,
3760 sizeof(elf_i386_plt0_entry
));
3761 memset (htab
->splt
->contents
+ sizeof (elf_i386_plt0_entry
),
3762 htab
->plt0_pad_byte
,
3763 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
3764 bfd_put_32 (output_bfd
,
3765 (htab
->sgotplt
->output_section
->vma
3766 + htab
->sgotplt
->output_offset
3768 htab
->splt
->contents
+ 2);
3769 bfd_put_32 (output_bfd
,
3770 (htab
->sgotplt
->output_section
->vma
3771 + htab
->sgotplt
->output_offset
3773 htab
->splt
->contents
+ 8);
3775 if (htab
->is_vxworks
)
3777 Elf_Internal_Rela rel
;
3779 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3780 On IA32 we use REL relocations so the addend goes in
3781 the PLT directly. */
3782 rel
.r_offset
= (htab
->splt
->output_section
->vma
3783 + htab
->splt
->output_offset
3785 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3786 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3787 htab
->srelplt2
->contents
);
3788 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
3789 rel
.r_offset
= (htab
->splt
->output_section
->vma
3790 + htab
->splt
->output_offset
3792 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3793 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3794 htab
->srelplt2
->contents
+
3795 sizeof (Elf32_External_Rel
));
3799 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3800 really seem like the right value. */
3801 elf_section_data (htab
->splt
->output_section
)
3802 ->this_hdr
.sh_entsize
= 4;
3804 /* Correct the .rel.plt.unloaded relocations. */
3805 if (htab
->is_vxworks
&& !info
->shared
)
3807 int num_plts
= (htab
->splt
->size
/ PLT_ENTRY_SIZE
) - 1;
3810 p
= htab
->srelplt2
->contents
;
3812 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
3814 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
3816 for (; num_plts
; num_plts
--)
3818 Elf_Internal_Rela rel
;
3819 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3820 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3821 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3822 p
+= sizeof (Elf32_External_Rel
);
3824 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3825 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
3826 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3827 p
+= sizeof (Elf32_External_Rel
);
3835 /* Fill in the first three entries in the global offset table. */
3836 if (htab
->sgotplt
->size
> 0)
3838 bfd_put_32 (output_bfd
,
3840 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3841 htab
->sgotplt
->contents
);
3842 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 4);
3843 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 8);
3846 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3849 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3850 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3855 /* Return address for Ith PLT stub in section PLT, for relocation REL
3856 or (bfd_vma) -1 if it should not be included. */
3859 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
3860 const arelent
*rel ATTRIBUTE_UNUSED
)
3862 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
3866 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3867 #define TARGET_LITTLE_NAME "elf32-i386"
3868 #define ELF_ARCH bfd_arch_i386
3869 #define ELF_MACHINE_CODE EM_386
3870 #define ELF_MAXPAGESIZE 0x1000
3872 #define elf_backend_can_gc_sections 1
3873 #define elf_backend_can_refcount 1
3874 #define elf_backend_want_got_plt 1
3875 #define elf_backend_plt_readonly 1
3876 #define elf_backend_want_plt_sym 0
3877 #define elf_backend_got_header_size 12
3879 /* Support RELA for objdump of prelink objects. */
3880 #define elf_info_to_howto elf_i386_info_to_howto_rel
3881 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3883 #define bfd_elf32_mkobject elf_i386_mkobject
3885 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3886 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3887 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3889 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3890 #define elf_backend_check_relocs elf_i386_check_relocs
3891 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3892 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3893 #define elf_backend_fake_sections elf_i386_fake_sections
3894 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3895 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3896 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3897 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3898 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3899 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3900 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3901 #define elf_backend_relocate_section elf_i386_relocate_section
3902 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3903 #define elf_backend_always_size_sections elf_i386_always_size_sections
3904 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
3906 #include "elf32-target.h"
3908 /* FreeBSD support. */
3910 #undef TARGET_LITTLE_SYM
3911 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3912 #undef TARGET_LITTLE_NAME
3913 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3915 /* The kernel recognizes executables as valid only if they carry a
3916 "FreeBSD" label in the ELF header. So we put this label on all
3917 executables and (for simplicity) also all other object files. */
3920 elf_i386_post_process_headers (bfd
*abfd
,
3921 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3923 Elf_Internal_Ehdr
*i_ehdrp
;
3925 i_ehdrp
= elf_elfheader (abfd
);
3927 /* Put an ABI label supported by FreeBSD >= 4.1. */
3928 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
3929 #ifdef OLD_FREEBSD_ABI_LABEL
3930 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3931 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
3935 #undef elf_backend_post_process_headers
3936 #define elf_backend_post_process_headers elf_i386_post_process_headers
3938 #define elf32_bed elf32_i386_fbsd_bed
3940 #include "elf32-target.h"
3942 /* VxWorks support. */
3944 #undef TARGET_LITTLE_SYM
3945 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
3946 #undef TARGET_LITTLE_NAME
3947 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
3950 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
3952 static struct bfd_link_hash_table
*
3953 elf_i386_vxworks_link_hash_table_create (bfd
*abfd
)
3955 struct bfd_link_hash_table
*ret
;
3956 struct elf_i386_link_hash_table
*htab
;
3958 ret
= elf_i386_link_hash_table_create (abfd
);
3961 htab
= (struct elf_i386_link_hash_table
*) ret
;
3962 htab
->is_vxworks
= 1;
3963 htab
->plt0_pad_byte
= 0x90;
3970 /* Tweak magic VxWorks symbols as they are written to the output file. */
3972 elf_i386_vxworks_link_output_symbol_hook (struct bfd_link_info
*info
3975 Elf_Internal_Sym
*sym
,
3976 asection
*input_sec ATTRIBUTE_UNUSED
,
3977 struct elf_link_hash_entry
*h
3980 /* Ignore the first dummy symbol. */
3984 return elf_vxworks_link_output_symbol_hook (name
, sym
);
3987 #undef elf_backend_post_process_headers
3988 #undef bfd_elf32_bfd_link_hash_table_create
3989 #define bfd_elf32_bfd_link_hash_table_create \
3990 elf_i386_vxworks_link_hash_table_create
3991 #undef elf_backend_add_symbol_hook
3992 #define elf_backend_add_symbol_hook \
3993 elf_vxworks_add_symbol_hook
3994 #undef elf_backend_link_output_symbol_hook
3995 #define elf_backend_link_output_symbol_hook \
3996 elf_i386_vxworks_link_output_symbol_hook
3997 #undef elf_backend_emit_relocs
3998 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
3999 #undef elf_backend_final_write_processing
4000 #define elf_backend_final_write_processing \
4001 elf_vxworks_final_write_processing
4003 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4005 #undef elf_backend_want_plt_sym
4006 #define elf_backend_want_plt_sym 1
4009 #define elf32_bed elf32_i386_vxworks_bed
4011 #include "elf32-target.h"