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 if (abfd
->tdata
.any
== NULL
)
627 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
628 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
629 if (abfd
->tdata
.any
== NULL
)
632 return bfd_elf_mkobject (abfd
);
635 /* i386 ELF linker hash table. */
637 struct elf_i386_link_hash_table
639 struct elf_link_hash_table elf
;
641 /* Short-cuts to get to dynamic linker sections. */
650 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
653 /* True if the target system is VxWorks. */
656 /* Value used to fill the last word of the first plt entry. */
657 bfd_byte plt0_pad_byte
;
659 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
660 bfd_vma next_tls_desc_index
;
663 bfd_signed_vma refcount
;
667 /* The amount of space used by the reserved portion of the sgotplt
668 section, plus whatever space is used by the jump slots. */
669 bfd_vma sgotplt_jump_table_size
;
671 /* Small local sym to section mapping cache. */
672 struct sym_sec_cache sym_sec
;
675 /* Get the i386 ELF linker hash table from a link_info structure. */
677 #define elf_i386_hash_table(p) \
678 ((struct elf_i386_link_hash_table *) ((p)->hash))
680 #define elf_i386_compute_jump_table_size(htab) \
681 ((htab)->next_tls_desc_index * 4)
683 /* Create an entry in an i386 ELF linker hash table. */
685 static struct bfd_hash_entry
*
686 link_hash_newfunc (struct bfd_hash_entry
*entry
,
687 struct bfd_hash_table
*table
,
690 /* Allocate the structure if it has not already been allocated by a
694 entry
= bfd_hash_allocate (table
,
695 sizeof (struct elf_i386_link_hash_entry
));
700 /* Call the allocation method of the superclass. */
701 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
704 struct elf_i386_link_hash_entry
*eh
;
706 eh
= (struct elf_i386_link_hash_entry
*) entry
;
707 eh
->dyn_relocs
= NULL
;
708 eh
->tls_type
= GOT_UNKNOWN
;
709 eh
->tlsdesc_got
= (bfd_vma
) -1;
715 /* Create an i386 ELF linker hash table. */
717 static struct bfd_link_hash_table
*
718 elf_i386_link_hash_table_create (bfd
*abfd
)
720 struct elf_i386_link_hash_table
*ret
;
721 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
723 ret
= bfd_malloc (amt
);
727 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
728 sizeof (struct elf_i386_link_hash_entry
)))
741 ret
->tls_ldm_got
.refcount
= 0;
742 ret
->next_tls_desc_index
= 0;
743 ret
->sgotplt_jump_table_size
= 0;
744 ret
->sym_sec
.abfd
= NULL
;
746 ret
->srelplt2
= NULL
;
747 ret
->plt0_pad_byte
= 0;
749 return &ret
->elf
.root
;
752 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
753 shortcuts to them in our hash table. */
756 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
758 struct elf_i386_link_hash_table
*htab
;
760 if (! _bfd_elf_create_got_section (dynobj
, info
))
763 htab
= elf_i386_hash_table (info
);
764 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
765 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
766 if (!htab
->sgot
|| !htab
->sgotplt
)
769 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rel.got",
770 (SEC_ALLOC
| SEC_LOAD
775 if (htab
->srelgot
== NULL
776 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
781 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
782 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
786 elf_i386_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
788 struct elf_i386_link_hash_table
*htab
;
790 htab
= elf_i386_hash_table (info
);
791 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
794 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
797 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
798 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
799 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
801 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
803 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
804 || (!info
->shared
&& !htab
->srelbss
))
808 && !elf_vxworks_create_dynamic_sections (dynobj
, info
, &htab
->srelplt2
))
814 /* Copy the extra info we tack onto an elf_link_hash_entry. */
817 elf_i386_copy_indirect_symbol (struct bfd_link_info
*info
,
818 struct elf_link_hash_entry
*dir
,
819 struct elf_link_hash_entry
*ind
)
821 struct elf_i386_link_hash_entry
*edir
, *eind
;
823 edir
= (struct elf_i386_link_hash_entry
*) dir
;
824 eind
= (struct elf_i386_link_hash_entry
*) ind
;
826 if (eind
->dyn_relocs
!= NULL
)
828 if (edir
->dyn_relocs
!= NULL
)
830 struct elf_i386_dyn_relocs
**pp
;
831 struct elf_i386_dyn_relocs
*p
;
833 /* Add reloc counts against the indirect sym to the direct sym
834 list. Merge any entries against the same section. */
835 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
837 struct elf_i386_dyn_relocs
*q
;
839 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
840 if (q
->sec
== p
->sec
)
842 q
->pc_count
+= p
->pc_count
;
843 q
->count
+= p
->count
;
850 *pp
= edir
->dyn_relocs
;
853 edir
->dyn_relocs
= eind
->dyn_relocs
;
854 eind
->dyn_relocs
= NULL
;
857 if (ind
->root
.type
== bfd_link_hash_indirect
858 && dir
->got
.refcount
<= 0)
860 edir
->tls_type
= eind
->tls_type
;
861 eind
->tls_type
= GOT_UNKNOWN
;
864 if (ELIMINATE_COPY_RELOCS
865 && ind
->root
.type
!= bfd_link_hash_indirect
866 && dir
->dynamic_adjusted
)
868 /* If called to transfer flags for a weakdef during processing
869 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
870 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
871 dir
->ref_dynamic
|= ind
->ref_dynamic
;
872 dir
->ref_regular
|= ind
->ref_regular
;
873 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
874 dir
->needs_plt
|= ind
->needs_plt
;
875 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
878 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
882 elf_i386_tls_transition (struct bfd_link_info
*info
, int r_type
, int is_local
)
890 case R_386_TLS_GOTDESC
:
891 case R_386_TLS_DESC_CALL
:
892 case R_386_TLS_IE_32
:
894 return R_386_TLS_LE_32
;
895 return R_386_TLS_IE_32
;
897 case R_386_TLS_GOTIE
:
899 return R_386_TLS_LE_32
;
902 return R_386_TLS_LE_32
;
908 /* Look through the relocs for a section during the first phase, and
909 calculate needed space in the global offset table, procedure linkage
910 table, and dynamic reloc sections. */
913 elf_i386_check_relocs (bfd
*abfd
,
914 struct bfd_link_info
*info
,
916 const Elf_Internal_Rela
*relocs
)
918 struct elf_i386_link_hash_table
*htab
;
919 Elf_Internal_Shdr
*symtab_hdr
;
920 struct elf_link_hash_entry
**sym_hashes
;
921 const Elf_Internal_Rela
*rel
;
922 const Elf_Internal_Rela
*rel_end
;
925 if (info
->relocatable
)
928 htab
= elf_i386_hash_table (info
);
929 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
930 sym_hashes
= elf_sym_hashes (abfd
);
934 rel_end
= relocs
+ sec
->reloc_count
;
935 for (rel
= relocs
; rel
< rel_end
; rel
++)
938 unsigned long r_symndx
;
939 struct elf_link_hash_entry
*h
;
941 r_symndx
= ELF32_R_SYM (rel
->r_info
);
942 r_type
= ELF32_R_TYPE (rel
->r_info
);
944 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
946 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
952 if (r_symndx
< symtab_hdr
->sh_info
)
956 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
957 while (h
->root
.type
== bfd_link_hash_indirect
958 || h
->root
.type
== bfd_link_hash_warning
)
959 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
962 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
967 htab
->tls_ldm_got
.refcount
+= 1;
971 /* This symbol requires a procedure linkage table entry. We
972 actually build the entry in adjust_dynamic_symbol,
973 because this might be a case of linking PIC code which is
974 never referenced by a dynamic object, in which case we
975 don't need to generate a procedure linkage table entry
978 /* If this is a local symbol, we resolve it directly without
979 creating a procedure linkage table entry. */
984 h
->plt
.refcount
+= 1;
987 case R_386_TLS_IE_32
:
989 case R_386_TLS_GOTIE
:
991 info
->flags
|= DF_STATIC_TLS
;
996 case R_386_TLS_GOTDESC
:
997 case R_386_TLS_DESC_CALL
:
998 /* This symbol requires a global offset table entry. */
1000 int tls_type
, old_tls_type
;
1005 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
1006 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
1007 case R_386_TLS_GOTDESC
:
1008 case R_386_TLS_DESC_CALL
:
1009 tls_type
= GOT_TLS_GDESC
; break;
1010 case R_386_TLS_IE_32
:
1011 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
1012 tls_type
= GOT_TLS_IE_NEG
;
1014 /* If this is a GD->IE transition, we may use either of
1015 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1016 tls_type
= GOT_TLS_IE
;
1019 case R_386_TLS_GOTIE
:
1020 tls_type
= GOT_TLS_IE_POS
; break;
1025 h
->got
.refcount
+= 1;
1026 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1030 bfd_signed_vma
*local_got_refcounts
;
1032 /* This is a global offset table entry for a local symbol. */
1033 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1034 if (local_got_refcounts
== NULL
)
1038 size
= symtab_hdr
->sh_info
;
1039 size
*= (sizeof (bfd_signed_vma
)
1040 + sizeof (bfd_vma
) + sizeof(char));
1041 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1042 if (local_got_refcounts
== NULL
)
1044 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1045 elf_i386_local_tlsdesc_gotent (abfd
)
1046 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1047 elf_i386_local_got_tls_type (abfd
)
1048 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1050 local_got_refcounts
[r_symndx
] += 1;
1051 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1054 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1055 tls_type
|= old_tls_type
;
1056 /* If a TLS symbol is accessed using IE at least once,
1057 there is no point to use dynamic model for it. */
1058 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1059 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1060 || (tls_type
& GOT_TLS_IE
) == 0))
1062 if ((old_tls_type
& GOT_TLS_IE
) && GOT_TLS_GD_ANY_P (tls_type
))
1063 tls_type
= old_tls_type
;
1064 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1065 && GOT_TLS_GD_ANY_P (tls_type
))
1066 tls_type
|= old_tls_type
;
1069 (*_bfd_error_handler
)
1070 (_("%B: `%s' accessed both as normal and "
1071 "thread local symbol"),
1073 h
? h
->root
.root
.string
: "<local>");
1078 if (old_tls_type
!= tls_type
)
1081 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1083 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1091 if (htab
->sgot
== NULL
)
1093 if (htab
->elf
.dynobj
== NULL
)
1094 htab
->elf
.dynobj
= abfd
;
1095 if (!create_got_section (htab
->elf
.dynobj
, info
))
1098 if (r_type
!= R_386_TLS_IE
)
1102 case R_386_TLS_LE_32
:
1106 info
->flags
|= DF_STATIC_TLS
;
1111 if (h
!= NULL
&& !info
->shared
)
1113 /* If this reloc is in a read-only section, we might
1114 need a copy reloc. We can't check reliably at this
1115 stage whether the section is read-only, as input
1116 sections have not yet been mapped to output sections.
1117 Tentatively set the flag for now, and correct in
1118 adjust_dynamic_symbol. */
1121 /* We may need a .plt entry if the function this reloc
1122 refers to is in a shared lib. */
1123 h
->plt
.refcount
+= 1;
1124 if (r_type
!= R_386_PC32
)
1125 h
->pointer_equality_needed
= 1;
1128 /* If we are creating a shared library, and this is a reloc
1129 against a global symbol, or a non PC relative reloc
1130 against a local symbol, then we need to copy the reloc
1131 into the shared library. However, if we are linking with
1132 -Bsymbolic, we do not need to copy a reloc against a
1133 global symbol which is defined in an object we are
1134 including in the link (i.e., DEF_REGULAR is set). At
1135 this point we have not seen all the input files, so it is
1136 possible that DEF_REGULAR is not set now but will be set
1137 later (it is never cleared). In case of a weak definition,
1138 DEF_REGULAR may be cleared later by a strong definition in
1139 a shared library. We account for that possibility below by
1140 storing information in the relocs_copied field of the hash
1141 table entry. A similar situation occurs when creating
1142 shared libraries and symbol visibility changes render the
1145 If on the other hand, we are creating an executable, we
1146 may need to keep relocations for symbols satisfied by a
1147 dynamic library if we manage to avoid copy relocs for the
1150 && (sec
->flags
& SEC_ALLOC
) != 0
1151 && (r_type
!= R_386_PC32
1153 && (! info
->symbolic
1154 || h
->root
.type
== bfd_link_hash_defweak
1155 || !h
->def_regular
))))
1156 || (ELIMINATE_COPY_RELOCS
1158 && (sec
->flags
& SEC_ALLOC
) != 0
1160 && (h
->root
.type
== bfd_link_hash_defweak
1161 || !h
->def_regular
)))
1163 struct elf_i386_dyn_relocs
*p
;
1164 struct elf_i386_dyn_relocs
**head
;
1166 /* We must copy these reloc types into the output file.
1167 Create a reloc section in dynobj and make room for
1173 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1174 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1176 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1180 if (strncmp (name
, ".rel", 4) != 0
1181 || strcmp (bfd_get_section_name (abfd
, sec
),
1184 (*_bfd_error_handler
)
1185 (_("%B: bad relocation section name `%s\'"),
1189 if (htab
->elf
.dynobj
== NULL
)
1190 htab
->elf
.dynobj
= abfd
;
1192 dynobj
= htab
->elf
.dynobj
;
1193 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1198 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1199 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1200 if ((sec
->flags
& SEC_ALLOC
) != 0)
1201 flags
|= SEC_ALLOC
| SEC_LOAD
;
1202 sreloc
= bfd_make_section_with_flags (dynobj
,
1206 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1209 elf_section_data (sec
)->sreloc
= sreloc
;
1212 /* If this is a global symbol, we count the number of
1213 relocations we need for this symbol. */
1216 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1221 /* Track dynamic relocs needed for local syms too.
1222 We really need local syms available to do this
1226 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1231 vpp
= &elf_section_data (s
)->local_dynrel
;
1232 head
= (struct elf_i386_dyn_relocs
**)vpp
;
1236 if (p
== NULL
|| p
->sec
!= sec
)
1238 bfd_size_type amt
= sizeof *p
;
1239 p
= bfd_alloc (htab
->elf
.dynobj
, amt
);
1250 if (r_type
== R_386_PC32
)
1255 /* This relocation describes the C++ object vtable hierarchy.
1256 Reconstruct it for later use during GC. */
1257 case R_386_GNU_VTINHERIT
:
1258 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1262 /* This relocation describes which C++ vtable entries are actually
1263 used. Record for later use during GC. */
1264 case R_386_GNU_VTENTRY
:
1265 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1277 /* Return the section that should be marked against GC for a given
1281 elf_i386_gc_mark_hook (asection
*sec
,
1282 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1283 Elf_Internal_Rela
*rel
,
1284 struct elf_link_hash_entry
*h
,
1285 Elf_Internal_Sym
*sym
)
1289 switch (ELF32_R_TYPE (rel
->r_info
))
1291 case R_386_GNU_VTINHERIT
:
1292 case R_386_GNU_VTENTRY
:
1296 switch (h
->root
.type
)
1298 case bfd_link_hash_defined
:
1299 case bfd_link_hash_defweak
:
1300 return h
->root
.u
.def
.section
;
1302 case bfd_link_hash_common
:
1303 return h
->root
.u
.c
.p
->section
;
1311 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1316 /* Update the got entry reference counts for the section being removed. */
1319 elf_i386_gc_sweep_hook (bfd
*abfd
,
1320 struct bfd_link_info
*info
,
1322 const Elf_Internal_Rela
*relocs
)
1324 Elf_Internal_Shdr
*symtab_hdr
;
1325 struct elf_link_hash_entry
**sym_hashes
;
1326 bfd_signed_vma
*local_got_refcounts
;
1327 const Elf_Internal_Rela
*rel
, *relend
;
1329 elf_section_data (sec
)->local_dynrel
= NULL
;
1331 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1332 sym_hashes
= elf_sym_hashes (abfd
);
1333 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1335 relend
= relocs
+ sec
->reloc_count
;
1336 for (rel
= relocs
; rel
< relend
; rel
++)
1338 unsigned long r_symndx
;
1339 unsigned int r_type
;
1340 struct elf_link_hash_entry
*h
= NULL
;
1342 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1343 if (r_symndx
>= symtab_hdr
->sh_info
)
1345 struct elf_i386_link_hash_entry
*eh
;
1346 struct elf_i386_dyn_relocs
**pp
;
1347 struct elf_i386_dyn_relocs
*p
;
1349 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1350 while (h
->root
.type
== bfd_link_hash_indirect
1351 || h
->root
.type
== bfd_link_hash_warning
)
1352 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1353 eh
= (struct elf_i386_link_hash_entry
*) h
;
1355 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1358 /* Everything must go for SEC. */
1364 r_type
= ELF32_R_TYPE (rel
->r_info
);
1365 r_type
= elf_i386_tls_transition (info
, r_type
, h
!= NULL
);
1369 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1370 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1374 case R_386_TLS_GOTDESC
:
1375 case R_386_TLS_DESC_CALL
:
1376 case R_386_TLS_IE_32
:
1378 case R_386_TLS_GOTIE
:
1382 if (h
->got
.refcount
> 0)
1383 h
->got
.refcount
-= 1;
1385 else if (local_got_refcounts
!= NULL
)
1387 if (local_got_refcounts
[r_symndx
] > 0)
1388 local_got_refcounts
[r_symndx
] -= 1;
1401 if (h
->plt
.refcount
> 0)
1402 h
->plt
.refcount
-= 1;
1414 /* Adjust a symbol defined by a dynamic object and referenced by a
1415 regular object. The current definition is in some section of the
1416 dynamic object, but we're not including those sections. We have to
1417 change the definition to something the rest of the link can
1421 elf_i386_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1422 struct elf_link_hash_entry
*h
)
1424 struct elf_i386_link_hash_table
*htab
;
1426 unsigned int power_of_two
;
1428 /* If this is a function, put it in the procedure linkage table. We
1429 will fill in the contents of the procedure linkage table later,
1430 when we know the address of the .got section. */
1431 if (h
->type
== STT_FUNC
1434 if (h
->plt
.refcount
<= 0
1435 || SYMBOL_CALLS_LOCAL (info
, h
)
1436 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1437 && h
->root
.type
== bfd_link_hash_undefweak
))
1439 /* This case can occur if we saw a PLT32 reloc in an input
1440 file, but the symbol was never referred to by a dynamic
1441 object, or if all references were garbage collected. In
1442 such a case, we don't actually need to build a procedure
1443 linkage table, and we can just do a PC32 reloc instead. */
1444 h
->plt
.offset
= (bfd_vma
) -1;
1451 /* It's possible that we incorrectly decided a .plt reloc was
1452 needed for an R_386_PC32 reloc to a non-function sym in
1453 check_relocs. We can't decide accurately between function and
1454 non-function syms in check-relocs; Objects loaded later in
1455 the link may change h->type. So fix it now. */
1456 h
->plt
.offset
= (bfd_vma
) -1;
1458 /* If this is a weak symbol, and there is a real definition, the
1459 processor independent code will have arranged for us to see the
1460 real definition first, and we can just use the same value. */
1461 if (h
->u
.weakdef
!= NULL
)
1463 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1464 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1465 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1466 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1467 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1468 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1472 /* This is a reference to a symbol defined by a dynamic object which
1473 is not a function. */
1475 /* If we are creating a shared library, we must presume that the
1476 only references to the symbol are via the global offset table.
1477 For such cases we need not do anything here; the relocations will
1478 be handled correctly by relocate_section. */
1482 /* If there are no references to this symbol that do not use the
1483 GOT, we don't need to generate a copy reloc. */
1484 if (!h
->non_got_ref
)
1487 /* If -z nocopyreloc was given, we won't generate them either. */
1488 if (info
->nocopyreloc
)
1494 htab
= elf_i386_hash_table (info
);
1496 /* If there aren't any dynamic relocs in read-only sections, then
1497 we can keep the dynamic relocs and avoid the copy reloc. This
1498 doesn't work on VxWorks, where we can not have dynamic relocations
1499 (other than copy and jump slot relocations) in an executable. */
1500 if (ELIMINATE_COPY_RELOCS
&& !htab
->is_vxworks
)
1502 struct elf_i386_link_hash_entry
* eh
;
1503 struct elf_i386_dyn_relocs
*p
;
1505 eh
= (struct elf_i386_link_hash_entry
*) h
;
1506 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1508 s
= p
->sec
->output_section
;
1509 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1522 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1523 h
->root
.root
.string
);
1527 /* We must allocate the symbol in our .dynbss section, which will
1528 become part of the .bss section of the executable. There will be
1529 an entry for this symbol in the .dynsym section. The dynamic
1530 object will contain position independent code, so all references
1531 from the dynamic object to this symbol will go through the global
1532 offset table. The dynamic linker will use the .dynsym entry to
1533 determine the address it must put in the global offset table, so
1534 both the dynamic object and the regular object will refer to the
1535 same memory location for the variable. */
1537 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1538 copy the initial value out of the dynamic object and into the
1539 runtime process image. */
1540 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1542 htab
->srelbss
->size
+= sizeof (Elf32_External_Rel
);
1546 /* We need to figure out the alignment required for this symbol. I
1547 have no idea how ELF linkers handle this. */
1548 power_of_two
= bfd_log2 (h
->size
);
1549 if (power_of_two
> 3)
1552 /* Apply the required alignment. */
1554 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1555 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1557 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1561 /* Define the symbol as being at this point in the section. */
1562 h
->root
.u
.def
.section
= s
;
1563 h
->root
.u
.def
.value
= s
->size
;
1565 /* Increment the section size to make room for the symbol. */
1571 /* Allocate space in .plt, .got and associated reloc sections for
1575 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1577 struct bfd_link_info
*info
;
1578 struct elf_i386_link_hash_table
*htab
;
1579 struct elf_i386_link_hash_entry
*eh
;
1580 struct elf_i386_dyn_relocs
*p
;
1582 if (h
->root
.type
== bfd_link_hash_indirect
)
1585 if (h
->root
.type
== bfd_link_hash_warning
)
1586 /* When warning symbols are created, they **replace** the "real"
1587 entry in the hash table, thus we never get to see the real
1588 symbol in a hash traversal. So look at it now. */
1589 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1591 info
= (struct bfd_link_info
*) inf
;
1592 htab
= elf_i386_hash_table (info
);
1594 if (htab
->elf
.dynamic_sections_created
1595 && h
->plt
.refcount
> 0)
1597 /* Make sure this symbol is output as a dynamic symbol.
1598 Undefined weak syms won't yet be marked as dynamic. */
1599 if (h
->dynindx
== -1
1600 && !h
->forced_local
)
1602 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1607 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1609 asection
*s
= htab
->splt
;
1611 /* If this is the first .plt entry, make room for the special
1614 s
->size
+= PLT_ENTRY_SIZE
;
1616 h
->plt
.offset
= s
->size
;
1618 /* If this symbol is not defined in a regular file, and we are
1619 not generating a shared library, then set the symbol to this
1620 location in the .plt. This is required to make function
1621 pointers compare as equal between the normal executable and
1622 the shared library. */
1626 h
->root
.u
.def
.section
= s
;
1627 h
->root
.u
.def
.value
= h
->plt
.offset
;
1630 /* Make room for this entry. */
1631 s
->size
+= PLT_ENTRY_SIZE
;
1633 /* We also need to make an entry in the .got.plt section, which
1634 will be placed in the .got section by the linker script. */
1635 htab
->sgotplt
->size
+= 4;
1637 /* We also need to make an entry in the .rel.plt section. */
1638 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1639 htab
->next_tls_desc_index
++;
1641 if (htab
->is_vxworks
&& !info
->shared
)
1643 /* VxWorks has a second set of relocations for each PLT entry
1644 in executables. They go in a separate relocation section,
1645 which is processed by the kernel loader. */
1647 /* There are two relocations for the initial PLT entry: an
1648 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1649 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1651 if (h
->plt
.offset
== PLT_ENTRY_SIZE
)
1652 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1654 /* There are two extra relocations for each subsequent PLT entry:
1655 an R_386_32 relocation for the GOT entry, and an R_386_32
1656 relocation for the PLT entry. */
1658 htab
->srelplt2
->size
+= (sizeof (Elf32_External_Rel
) * 2);
1663 h
->plt
.offset
= (bfd_vma
) -1;
1669 h
->plt
.offset
= (bfd_vma
) -1;
1673 eh
= (struct elf_i386_link_hash_entry
*) h
;
1674 eh
->tlsdesc_got
= (bfd_vma
) -1;
1676 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1677 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1678 if (h
->got
.refcount
> 0
1681 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
1682 h
->got
.offset
= (bfd_vma
) -1;
1683 else if (h
->got
.refcount
> 0)
1687 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1689 /* Make sure this symbol is output as a dynamic symbol.
1690 Undefined weak syms won't yet be marked as dynamic. */
1691 if (h
->dynindx
== -1
1692 && !h
->forced_local
)
1694 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1699 if (GOT_TLS_GDESC_P (tls_type
))
1701 eh
->tlsdesc_got
= htab
->sgotplt
->size
1702 - elf_i386_compute_jump_table_size (htab
);
1703 htab
->sgotplt
->size
+= 8;
1704 h
->got
.offset
= (bfd_vma
) -2;
1706 if (! GOT_TLS_GDESC_P (tls_type
)
1707 || GOT_TLS_GD_P (tls_type
))
1709 h
->got
.offset
= s
->size
;
1711 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1712 if (GOT_TLS_GD_P (tls_type
) || tls_type
== GOT_TLS_IE_BOTH
)
1715 dyn
= htab
->elf
.dynamic_sections_created
;
1716 /* R_386_TLS_IE_32 needs one dynamic relocation,
1717 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1718 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1719 need two), R_386_TLS_GD needs one if local symbol and two if
1721 if (tls_type
== GOT_TLS_IE_BOTH
)
1722 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1723 else if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
1724 || (tls_type
& GOT_TLS_IE
))
1725 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1726 else if (GOT_TLS_GD_P (tls_type
))
1727 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rel
);
1728 else if (! GOT_TLS_GDESC_P (tls_type
)
1729 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1730 || h
->root
.type
!= bfd_link_hash_undefweak
)
1732 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
1733 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1734 if (GOT_TLS_GDESC_P (tls_type
))
1735 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1738 h
->got
.offset
= (bfd_vma
) -1;
1740 if (eh
->dyn_relocs
== NULL
)
1743 /* In the shared -Bsymbolic case, discard space allocated for
1744 dynamic pc-relative relocs against symbols which turn out to be
1745 defined in regular objects. For the normal shared case, discard
1746 space for pc-relative relocs that have become local due to symbol
1747 visibility changes. */
1751 /* The only reloc that uses pc_count is R_386_PC32, which will
1752 appear on a call or on something like ".long foo - .". We
1753 want calls to protected symbols to resolve directly to the
1754 function rather than going via the plt. If people want
1755 function pointer comparisons to work as expected then they
1756 should avoid writing assembly like ".long foo - .". */
1757 if (SYMBOL_CALLS_LOCAL (info
, h
))
1759 struct elf_i386_dyn_relocs
**pp
;
1761 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1763 p
->count
-= p
->pc_count
;
1772 /* Also discard relocs on undefined weak syms with non-default
1774 if (eh
->dyn_relocs
!= NULL
1775 && h
->root
.type
== bfd_link_hash_undefweak
)
1777 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1778 eh
->dyn_relocs
= NULL
;
1780 /* Make sure undefined weak symbols are output as a dynamic
1782 else if (h
->dynindx
== -1
1783 && !h
->forced_local
)
1785 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1790 else if (ELIMINATE_COPY_RELOCS
)
1792 /* For the non-shared case, discard space for relocs against
1793 symbols which turn out to need copy relocs or are not
1799 || (htab
->elf
.dynamic_sections_created
1800 && (h
->root
.type
== bfd_link_hash_undefweak
1801 || h
->root
.type
== bfd_link_hash_undefined
))))
1803 /* Make sure this symbol is output as a dynamic symbol.
1804 Undefined weak syms won't yet be marked as dynamic. */
1805 if (h
->dynindx
== -1
1806 && !h
->forced_local
)
1808 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1812 /* If that succeeded, we know we'll be keeping all the
1814 if (h
->dynindx
!= -1)
1818 eh
->dyn_relocs
= NULL
;
1823 /* Finally, allocate space. */
1824 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1826 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1827 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1833 /* Find any dynamic relocs that apply to read-only sections. */
1836 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1838 struct elf_i386_link_hash_entry
*eh
;
1839 struct elf_i386_dyn_relocs
*p
;
1841 if (h
->root
.type
== bfd_link_hash_warning
)
1842 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1844 eh
= (struct elf_i386_link_hash_entry
*) h
;
1845 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1847 asection
*s
= p
->sec
->output_section
;
1849 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1851 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1853 info
->flags
|= DF_TEXTREL
;
1855 /* Not an error, just cut short the traversal. */
1862 /* Set the sizes of the dynamic sections. */
1865 elf_i386_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1866 struct bfd_link_info
*info
)
1868 struct elf_i386_link_hash_table
*htab
;
1874 htab
= elf_i386_hash_table (info
);
1875 dynobj
= htab
->elf
.dynobj
;
1879 if (htab
->elf
.dynamic_sections_created
)
1881 /* Set the contents of the .interp section to the interpreter. */
1882 if (info
->executable
)
1884 s
= bfd_get_section_by_name (dynobj
, ".interp");
1887 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1888 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1892 /* Set up .got offsets for local syms, and space for local dynamic
1894 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1896 bfd_signed_vma
*local_got
;
1897 bfd_signed_vma
*end_local_got
;
1898 char *local_tls_type
;
1899 bfd_vma
*local_tlsdesc_gotent
;
1900 bfd_size_type locsymcount
;
1901 Elf_Internal_Shdr
*symtab_hdr
;
1904 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1907 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1909 struct elf_i386_dyn_relocs
*p
;
1911 for (p
= ((struct elf_i386_dyn_relocs
*)
1912 elf_section_data (s
)->local_dynrel
);
1916 if (!bfd_is_abs_section (p
->sec
)
1917 && bfd_is_abs_section (p
->sec
->output_section
))
1919 /* Input section has been discarded, either because
1920 it is a copy of a linkonce section or due to
1921 linker script /DISCARD/, so we'll be discarding
1924 else if (p
->count
!= 0)
1926 srel
= elf_section_data (p
->sec
)->sreloc
;
1927 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
1928 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1929 info
->flags
|= DF_TEXTREL
;
1934 local_got
= elf_local_got_refcounts (ibfd
);
1938 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1939 locsymcount
= symtab_hdr
->sh_info
;
1940 end_local_got
= local_got
+ locsymcount
;
1941 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1942 local_tlsdesc_gotent
= elf_i386_local_tlsdesc_gotent (ibfd
);
1944 srel
= htab
->srelgot
;
1945 for (; local_got
< end_local_got
;
1946 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
1948 *local_tlsdesc_gotent
= (bfd_vma
) -1;
1951 if (GOT_TLS_GDESC_P (*local_tls_type
))
1953 *local_tlsdesc_gotent
= htab
->sgotplt
->size
1954 - elf_i386_compute_jump_table_size (htab
);
1955 htab
->sgotplt
->size
+= 8;
1956 *local_got
= (bfd_vma
) -2;
1958 if (! GOT_TLS_GDESC_P (*local_tls_type
)
1959 || GOT_TLS_GD_P (*local_tls_type
))
1961 *local_got
= s
->size
;
1963 if (GOT_TLS_GD_P (*local_tls_type
)
1964 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1968 || GOT_TLS_GD_ANY_P (*local_tls_type
)
1969 || (*local_tls_type
& GOT_TLS_IE
))
1971 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1972 srel
->size
+= 2 * sizeof (Elf32_External_Rel
);
1973 else if (GOT_TLS_GD_P (*local_tls_type
)
1974 || ! GOT_TLS_GDESC_P (*local_tls_type
))
1975 srel
->size
+= sizeof (Elf32_External_Rel
);
1976 if (GOT_TLS_GDESC_P (*local_tls_type
))
1977 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
1981 *local_got
= (bfd_vma
) -1;
1985 if (htab
->tls_ldm_got
.refcount
> 0)
1987 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1989 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
1990 htab
->sgot
->size
+= 8;
1991 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
1994 htab
->tls_ldm_got
.offset
= -1;
1996 /* Allocate global sym .plt and .got entries, and space for global
1997 sym dynamic relocs. */
1998 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2000 /* For every jump slot reserved in the sgotplt, reloc_count is
2001 incremented. However, when we reserve space for TLS descriptors,
2002 it's not incremented, so in order to compute the space reserved
2003 for them, it suffices to multiply the reloc count by the jump
2006 htab
->sgotplt_jump_table_size
= htab
->next_tls_desc_index
* 4;
2008 /* We now have determined the sizes of the various dynamic sections.
2009 Allocate memory for them. */
2011 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2013 bfd_boolean strip_section
= TRUE
;
2015 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2020 || s
== htab
->sgotplt
2021 || s
== htab
->sdynbss
)
2023 /* Strip this section if we don't need it; see the
2025 /* We'd like to strip these sections if they aren't needed, but if
2026 we've exported dynamic symbols from them we must leave them.
2027 It's too late to tell BFD to get rid of the symbols. */
2029 if (htab
->elf
.hplt
!= NULL
)
2030 strip_section
= FALSE
;
2032 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
2034 if (s
->size
!= 0 && s
!= htab
->srelplt
&& s
!= htab
->srelplt2
)
2037 /* We use the reloc_count field as a counter if we need
2038 to copy relocs into the output file. */
2043 /* It's not one of our sections, so don't allocate space. */
2049 /* If we don't need this section, strip it from the
2050 output file. This is mostly to handle .rel.bss and
2051 .rel.plt. We must create both sections in
2052 create_dynamic_sections, because they must be created
2053 before the linker maps input sections to output
2054 sections. The linker does that before
2055 adjust_dynamic_symbol is called, and it is that
2056 function which decides whether anything needs to go
2057 into these sections. */
2059 s
->flags
|= SEC_EXCLUDE
;
2063 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2066 /* Allocate memory for the section contents. We use bfd_zalloc
2067 here in case unused entries are not reclaimed before the
2068 section's contents are written out. This should not happen,
2069 but this way if it does, we get a R_386_NONE reloc instead
2071 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2072 if (s
->contents
== NULL
)
2076 if (htab
->elf
.dynamic_sections_created
)
2078 /* Add some entries to the .dynamic section. We fill in the
2079 values later, in elf_i386_finish_dynamic_sections, but we
2080 must add the entries now so that we get the correct size for
2081 the .dynamic section. The DT_DEBUG entry is filled in by the
2082 dynamic linker and used by the debugger. */
2083 #define add_dynamic_entry(TAG, VAL) \
2084 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2086 if (info
->executable
)
2088 if (!add_dynamic_entry (DT_DEBUG
, 0))
2092 if (htab
->splt
->size
!= 0)
2094 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2095 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2096 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
2097 || !add_dynamic_entry (DT_JMPREL
, 0))
2103 if (!add_dynamic_entry (DT_REL
, 0)
2104 || !add_dynamic_entry (DT_RELSZ
, 0)
2105 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
2108 /* If any dynamic relocs apply to a read-only section,
2109 then we need a DT_TEXTREL entry. */
2110 if ((info
->flags
& DF_TEXTREL
) == 0)
2111 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2114 if ((info
->flags
& DF_TEXTREL
) != 0)
2116 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2121 #undef add_dynamic_entry
2127 elf_i386_always_size_sections (bfd
*output_bfd
,
2128 struct bfd_link_info
*info
)
2130 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2134 struct elf_link_hash_entry
*tlsbase
;
2136 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2137 "_TLS_MODULE_BASE_",
2138 FALSE
, FALSE
, FALSE
);
2140 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2142 struct bfd_link_hash_entry
*bh
= NULL
;
2143 const struct elf_backend_data
*bed
2144 = get_elf_backend_data (output_bfd
);
2146 if (!(_bfd_generic_link_add_one_symbol
2147 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2148 tls_sec
, 0, NULL
, FALSE
,
2149 bed
->collect
, &bh
)))
2151 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2152 tlsbase
->def_regular
= 1;
2153 tlsbase
->other
= STV_HIDDEN
;
2154 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2161 /* Set the correct type for an x86 ELF section. We do this by the
2162 section name, which is a hack, but ought to work. */
2165 elf_i386_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
2166 Elf_Internal_Shdr
*hdr
,
2169 register const char *name
;
2171 name
= bfd_get_section_name (abfd
, sec
);
2173 /* This is an ugly, but unfortunately necessary hack that is
2174 needed when producing EFI binaries on x86. It tells
2175 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2176 containing ELF relocation info. We need this hack in order to
2177 be able to generate ELF binaries that can be translated into
2178 EFI applications (which are essentially COFF objects). Those
2179 files contain a COFF ".reloc" section inside an ELFNN object,
2180 which would normally cause BFD to segfault because it would
2181 attempt to interpret this section as containing relocation
2182 entries for section "oc". With this hack enabled, ".reloc"
2183 will be treated as a normal data section, which will avoid the
2184 segfault. However, you won't be able to create an ELFNN binary
2185 with a section named "oc" that needs relocations, but that's
2186 the kind of ugly side-effects you get when detecting section
2187 types based on their names... In practice, this limitation is
2188 unlikely to bite. */
2189 if (strcmp (name
, ".reloc") == 0)
2190 hdr
->sh_type
= SHT_PROGBITS
;
2195 /* Return the base VMA address which should be subtracted from real addresses
2196 when resolving @dtpoff relocation.
2197 This is PT_TLS segment p_vaddr. */
2200 dtpoff_base (struct bfd_link_info
*info
)
2202 /* If tls_sec is NULL, we should have signalled an error already. */
2203 if (elf_hash_table (info
)->tls_sec
== NULL
)
2205 return elf_hash_table (info
)->tls_sec
->vma
;
2208 /* Return the relocation value for @tpoff relocation
2209 if STT_TLS virtual address is ADDRESS. */
2212 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2214 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2216 /* If tls_sec is NULL, we should have signalled an error already. */
2217 if (htab
->tls_sec
== NULL
)
2219 return htab
->tls_size
+ htab
->tls_sec
->vma
- address
;
2222 /* Relocate an i386 ELF section. */
2225 elf_i386_relocate_section (bfd
*output_bfd
,
2226 struct bfd_link_info
*info
,
2228 asection
*input_section
,
2230 Elf_Internal_Rela
*relocs
,
2231 Elf_Internal_Sym
*local_syms
,
2232 asection
**local_sections
)
2234 struct elf_i386_link_hash_table
*htab
;
2235 Elf_Internal_Shdr
*symtab_hdr
;
2236 struct elf_link_hash_entry
**sym_hashes
;
2237 bfd_vma
*local_got_offsets
;
2238 bfd_vma
*local_tlsdesc_gotents
;
2239 Elf_Internal_Rela
*rel
;
2240 Elf_Internal_Rela
*relend
;
2242 htab
= elf_i386_hash_table (info
);
2243 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2244 sym_hashes
= elf_sym_hashes (input_bfd
);
2245 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2246 local_tlsdesc_gotents
= elf_i386_local_tlsdesc_gotent (input_bfd
);
2249 relend
= relocs
+ input_section
->reloc_count
;
2250 for (; rel
< relend
; rel
++)
2252 unsigned int r_type
;
2253 reloc_howto_type
*howto
;
2254 unsigned long r_symndx
;
2255 struct elf_link_hash_entry
*h
;
2256 Elf_Internal_Sym
*sym
;
2258 bfd_vma off
, offplt
;
2260 bfd_boolean unresolved_reloc
;
2261 bfd_reloc_status_type r
;
2265 r_type
= ELF32_R_TYPE (rel
->r_info
);
2266 if (r_type
== R_386_GNU_VTINHERIT
2267 || r_type
== R_386_GNU_VTENTRY
)
2270 if ((indx
= r_type
) >= R_386_standard
2271 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2272 >= R_386_ext
- R_386_standard
)
2273 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2274 >= R_386_tls
- R_386_ext
))
2276 (*_bfd_error_handler
)
2277 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2278 input_bfd
, input_section
, r_type
);
2279 bfd_set_error (bfd_error_bad_value
);
2282 howto
= elf_howto_table
+ indx
;
2284 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2286 if (info
->relocatable
)
2291 /* This is a relocatable link. We don't have to change
2292 anything, unless the reloc is against a section symbol,
2293 in which case we have to adjust according to where the
2294 section symbol winds up in the output section. */
2295 if (r_symndx
>= symtab_hdr
->sh_info
)
2298 sym
= local_syms
+ r_symndx
;
2299 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2302 sec
= local_sections
[r_symndx
];
2303 val
= sec
->output_offset
;
2307 where
= contents
+ rel
->r_offset
;
2308 switch (howto
->size
)
2310 /* FIXME: overflow checks. */
2312 val
+= bfd_get_8 (input_bfd
, where
);
2313 bfd_put_8 (input_bfd
, val
, where
);
2316 val
+= bfd_get_16 (input_bfd
, where
);
2317 bfd_put_16 (input_bfd
, val
, where
);
2320 val
+= bfd_get_32 (input_bfd
, where
);
2321 bfd_put_32 (input_bfd
, val
, where
);
2329 /* This is a final link. */
2333 unresolved_reloc
= FALSE
;
2334 if (r_symndx
< symtab_hdr
->sh_info
)
2336 sym
= local_syms
+ r_symndx
;
2337 sec
= local_sections
[r_symndx
];
2338 relocation
= (sec
->output_section
->vma
2339 + sec
->output_offset
2341 if ((sec
->flags
& SEC_MERGE
)
2342 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2346 bfd_byte
*where
= contents
+ rel
->r_offset
;
2348 switch (howto
->size
)
2351 addend
= bfd_get_8 (input_bfd
, where
);
2352 if (howto
->pc_relative
)
2354 addend
= (addend
^ 0x80) - 0x80;
2359 addend
= bfd_get_16 (input_bfd
, where
);
2360 if (howto
->pc_relative
)
2362 addend
= (addend
^ 0x8000) - 0x8000;
2367 addend
= bfd_get_32 (input_bfd
, where
);
2368 if (howto
->pc_relative
)
2370 addend
= (addend
^ 0x80000000) - 0x80000000;
2379 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2380 addend
-= relocation
;
2381 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2383 switch (howto
->size
)
2386 /* FIXME: overflow checks. */
2387 if (howto
->pc_relative
)
2389 bfd_put_8 (input_bfd
, addend
, where
);
2392 if (howto
->pc_relative
)
2394 bfd_put_16 (input_bfd
, addend
, where
);
2397 if (howto
->pc_relative
)
2399 bfd_put_32 (input_bfd
, addend
, where
);
2408 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2409 r_symndx
, symtab_hdr
, sym_hashes
,
2411 unresolved_reloc
, warned
);
2416 /* r_symndx will be zero only for relocs against symbols from
2417 removed linkonce sections, or sections discarded by a linker
2418 script. For these relocs, we just want the section contents
2419 zeroed. Avoid any special processing in the switch below. */
2420 r_type
= R_386_NONE
;
2423 if (howto
->pc_relative
)
2424 relocation
= (input_section
->output_section
->vma
2425 + input_section
->output_offset
2432 /* Relocation is to the entry for this symbol in the global
2434 if (htab
->sgot
== NULL
)
2441 off
= h
->got
.offset
;
2442 dyn
= htab
->elf
.dynamic_sections_created
;
2443 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2445 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2446 || (ELF_ST_VISIBILITY (h
->other
)
2447 && h
->root
.type
== bfd_link_hash_undefweak
))
2449 /* This is actually a static link, or it is a
2450 -Bsymbolic link and the symbol is defined
2451 locally, or the symbol was forced to be local
2452 because of a version file. We must initialize
2453 this entry in the global offset table. Since the
2454 offset must always be a multiple of 4, we use the
2455 least significant bit to record whether we have
2456 initialized it already.
2458 When doing a dynamic link, we create a .rel.got
2459 relocation entry to initialize the value. This
2460 is done in the finish_dynamic_symbol routine. */
2465 bfd_put_32 (output_bfd
, relocation
,
2466 htab
->sgot
->contents
+ off
);
2471 unresolved_reloc
= FALSE
;
2475 if (local_got_offsets
== NULL
)
2478 off
= local_got_offsets
[r_symndx
];
2480 /* The offset must always be a multiple of 4. We use
2481 the least significant bit to record whether we have
2482 already generated the necessary reloc. */
2487 bfd_put_32 (output_bfd
, relocation
,
2488 htab
->sgot
->contents
+ off
);
2493 Elf_Internal_Rela outrel
;
2500 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2501 + htab
->sgot
->output_offset
2503 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2505 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2506 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2509 local_got_offsets
[r_symndx
] |= 1;
2513 if (off
>= (bfd_vma
) -2)
2516 relocation
= htab
->sgot
->output_section
->vma
2517 + htab
->sgot
->output_offset
+ off
2518 - htab
->sgotplt
->output_section
->vma
2519 - htab
->sgotplt
->output_offset
;
2523 /* Relocation is relative to the start of the global offset
2526 /* Check to make sure it isn't a protected function symbol
2527 for shared library since it may not be local when used
2528 as function address. */
2530 && !info
->executable
2533 && h
->type
== STT_FUNC
2534 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
2536 (*_bfd_error_handler
)
2537 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2538 input_bfd
, h
->root
.root
.string
);
2539 bfd_set_error (bfd_error_bad_value
);
2543 /* Note that sgot is not involved in this
2544 calculation. We always want the start of .got.plt. If we
2545 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2546 permitted by the ABI, we might have to change this
2548 relocation
-= htab
->sgotplt
->output_section
->vma
2549 + htab
->sgotplt
->output_offset
;
2553 /* Use global offset table as symbol value. */
2554 relocation
= htab
->sgotplt
->output_section
->vma
2555 + htab
->sgotplt
->output_offset
;
2556 unresolved_reloc
= FALSE
;
2560 /* Relocation is to the entry for this symbol in the
2561 procedure linkage table. */
2563 /* Resolve a PLT32 reloc against a local symbol directly,
2564 without using the procedure linkage table. */
2568 if (h
->plt
.offset
== (bfd_vma
) -1
2569 || htab
->splt
== NULL
)
2571 /* We didn't make a PLT entry for this symbol. This
2572 happens when statically linking PIC code, or when
2573 using -Bsymbolic. */
2577 relocation
= (htab
->splt
->output_section
->vma
2578 + htab
->splt
->output_offset
2580 unresolved_reloc
= FALSE
;
2585 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2590 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2591 || h
->root
.type
!= bfd_link_hash_undefweak
)
2592 && (r_type
!= R_386_PC32
2593 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2594 || (ELIMINATE_COPY_RELOCS
2601 || h
->root
.type
== bfd_link_hash_undefweak
2602 || h
->root
.type
== bfd_link_hash_undefined
)))
2604 Elf_Internal_Rela outrel
;
2606 bfd_boolean skip
, relocate
;
2609 /* When generating a shared object, these relocations
2610 are copied into the output file to be resolved at run
2617 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2619 if (outrel
.r_offset
== (bfd_vma
) -1)
2621 else if (outrel
.r_offset
== (bfd_vma
) -2)
2622 skip
= TRUE
, relocate
= TRUE
;
2623 outrel
.r_offset
+= (input_section
->output_section
->vma
2624 + input_section
->output_offset
);
2627 memset (&outrel
, 0, sizeof outrel
);
2630 && (r_type
== R_386_PC32
2633 || !h
->def_regular
))
2634 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2637 /* This symbol is local, or marked to become local. */
2639 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2642 sreloc
= elf_section_data (input_section
)->sreloc
;
2646 loc
= sreloc
->contents
;
2647 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2648 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2650 /* If this reloc is against an external symbol, we do
2651 not want to fiddle with the addend. Otherwise, we
2652 need to include the symbol value so that it becomes
2653 an addend for the dynamic reloc. */
2662 Elf_Internal_Rela outrel
;
2666 outrel
.r_offset
= rel
->r_offset
2667 + input_section
->output_section
->vma
2668 + input_section
->output_offset
;
2669 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2670 sreloc
= elf_section_data (input_section
)->sreloc
;
2673 loc
= sreloc
->contents
;
2674 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2675 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2680 case R_386_TLS_GOTDESC
:
2681 case R_386_TLS_DESC_CALL
:
2682 case R_386_TLS_IE_32
:
2683 case R_386_TLS_GOTIE
:
2684 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2685 tls_type
= GOT_UNKNOWN
;
2686 if (h
== NULL
&& local_got_offsets
)
2687 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2690 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2691 if (!info
->shared
&& h
->dynindx
== -1 && (tls_type
& GOT_TLS_IE
))
2692 r_type
= R_386_TLS_LE_32
;
2694 if (tls_type
== GOT_TLS_IE
)
2695 tls_type
= GOT_TLS_IE_NEG
;
2696 if (r_type
== R_386_TLS_GD
2697 || r_type
== R_386_TLS_GOTDESC
2698 || r_type
== R_386_TLS_DESC_CALL
)
2700 if (tls_type
== GOT_TLS_IE_POS
)
2701 r_type
= R_386_TLS_GOTIE
;
2702 else if (tls_type
& GOT_TLS_IE
)
2703 r_type
= R_386_TLS_IE_32
;
2706 if (r_type
== R_386_TLS_LE_32
)
2708 BFD_ASSERT (! unresolved_reloc
);
2709 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2711 unsigned int val
, type
;
2714 /* GD->LE transition. */
2715 BFD_ASSERT (rel
->r_offset
>= 2);
2716 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2717 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2718 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
2719 BFD_ASSERT (bfd_get_8 (input_bfd
,
2720 contents
+ rel
->r_offset
+ 4)
2722 BFD_ASSERT (rel
+ 1 < relend
);
2723 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2724 roff
= rel
->r_offset
+ 5;
2725 val
= bfd_get_8 (input_bfd
,
2726 contents
+ rel
->r_offset
- 1);
2729 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2731 movl %gs:0, %eax; subl $foo@tpoff, %eax
2732 (6 byte form of subl). */
2733 BFD_ASSERT (rel
->r_offset
>= 3);
2734 BFD_ASSERT (bfd_get_8 (input_bfd
,
2735 contents
+ rel
->r_offset
- 3)
2737 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2738 memcpy (contents
+ rel
->r_offset
- 3,
2739 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2743 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2744 if (rel
->r_offset
+ 10 <= input_section
->size
2745 && bfd_get_8 (input_bfd
,
2746 contents
+ rel
->r_offset
+ 9) == 0x90)
2748 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2750 movl %gs:0, %eax; subl $foo@tpoff, %eax
2751 (6 byte form of subl). */
2752 memcpy (contents
+ rel
->r_offset
- 2,
2753 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2754 roff
= rel
->r_offset
+ 6;
2758 /* leal foo(%reg), %eax; call ___tls_get_addr
2760 movl %gs:0, %eax; subl $foo@tpoff, %eax
2761 (5 byte form of subl). */
2762 memcpy (contents
+ rel
->r_offset
- 2,
2763 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2766 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2768 /* Skip R_386_PLT32. */
2772 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
2774 /* GDesc -> LE transition.
2775 It's originally something like:
2776 leal x@tlsdesc(%ebx), %eax
2780 Registers other than %eax may be set up here. */
2782 unsigned int val
, type
;
2785 /* First, make sure it's a leal adding ebx to a
2786 32-bit offset into any register, although it's
2787 probably almost always going to be eax. */
2788 roff
= rel
->r_offset
;
2789 BFD_ASSERT (roff
>= 2);
2790 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
2791 BFD_ASSERT (type
== 0x8d);
2792 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
2793 BFD_ASSERT ((val
& 0xc7) == 0x83);
2794 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
2796 /* Now modify the instruction as appropriate. */
2797 /* aoliva FIXME: remove the above and xor the byte
2799 bfd_put_8 (output_bfd
, val
^ 0x86,
2800 contents
+ roff
- 1);
2801 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2805 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
2807 /* GDesc -> LE transition.
2813 unsigned int val
, type
;
2816 /* First, make sure it's a call *(%eax). */
2817 roff
= rel
->r_offset
;
2818 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
2819 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
2820 BFD_ASSERT (type
== 0xff);
2821 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
2822 BFD_ASSERT (val
== 0x10);
2824 /* Now modify the instruction as appropriate. */
2825 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
2826 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
2829 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
2831 unsigned int val
, type
;
2833 /* IE->LE transition:
2834 Originally it can be one of:
2842 BFD_ASSERT (rel
->r_offset
>= 1);
2843 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2844 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2847 /* movl foo, %eax. */
2848 bfd_put_8 (output_bfd
, 0xb8,
2849 contents
+ rel
->r_offset
- 1);
2853 BFD_ASSERT (rel
->r_offset
>= 2);
2854 type
= bfd_get_8 (input_bfd
,
2855 contents
+ rel
->r_offset
- 2);
2860 BFD_ASSERT ((val
& 0xc7) == 0x05);
2861 bfd_put_8 (output_bfd
, 0xc7,
2862 contents
+ rel
->r_offset
- 2);
2863 bfd_put_8 (output_bfd
,
2864 0xc0 | ((val
>> 3) & 7),
2865 contents
+ rel
->r_offset
- 1);
2869 BFD_ASSERT ((val
& 0xc7) == 0x05);
2870 bfd_put_8 (output_bfd
, 0x81,
2871 contents
+ rel
->r_offset
- 2);
2872 bfd_put_8 (output_bfd
,
2873 0xc0 | ((val
>> 3) & 7),
2874 contents
+ rel
->r_offset
- 1);
2881 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2882 contents
+ rel
->r_offset
);
2887 unsigned int val
, type
;
2889 /* {IE_32,GOTIE}->LE transition:
2890 Originally it can be one of:
2891 subl foo(%reg1), %reg2
2892 movl foo(%reg1), %reg2
2893 addl foo(%reg1), %reg2
2896 movl $foo, %reg2 (6 byte form)
2897 addl $foo, %reg2. */
2898 BFD_ASSERT (rel
->r_offset
>= 2);
2899 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2900 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2901 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2902 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2906 bfd_put_8 (output_bfd
, 0xc7,
2907 contents
+ rel
->r_offset
- 2);
2908 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2909 contents
+ rel
->r_offset
- 1);
2911 else if (type
== 0x2b)
2914 bfd_put_8 (output_bfd
, 0x81,
2915 contents
+ rel
->r_offset
- 2);
2916 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2917 contents
+ rel
->r_offset
- 1);
2919 else if (type
== 0x03)
2922 bfd_put_8 (output_bfd
, 0x81,
2923 contents
+ rel
->r_offset
- 2);
2924 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2925 contents
+ rel
->r_offset
- 1);
2929 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
2930 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2931 contents
+ rel
->r_offset
);
2933 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2934 contents
+ rel
->r_offset
);
2939 if (htab
->sgot
== NULL
)
2944 off
= h
->got
.offset
;
2945 offplt
= elf_i386_hash_entry (h
)->tlsdesc_got
;
2949 if (local_got_offsets
== NULL
)
2952 off
= local_got_offsets
[r_symndx
];
2953 offplt
= local_tlsdesc_gotents
[r_symndx
];
2960 Elf_Internal_Rela outrel
;
2965 if (htab
->srelgot
== NULL
)
2968 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2970 if (GOT_TLS_GDESC_P (tls_type
))
2972 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_DESC
);
2973 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
+ 8
2974 <= htab
->sgotplt
->size
);
2975 outrel
.r_offset
= (htab
->sgotplt
->output_section
->vma
2976 + htab
->sgotplt
->output_offset
2978 + htab
->sgotplt_jump_table_size
);
2979 sreloc
= htab
->srelplt
;
2980 loc
= sreloc
->contents
;
2981 loc
+= (htab
->next_tls_desc_index
++
2982 * sizeof (Elf32_External_Rel
));
2983 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
2984 <= sreloc
->contents
+ sreloc
->size
);
2985 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2988 BFD_ASSERT (! unresolved_reloc
);
2989 bfd_put_32 (output_bfd
,
2990 relocation
- dtpoff_base (info
),
2991 htab
->sgotplt
->contents
+ offplt
2992 + htab
->sgotplt_jump_table_size
+ 4);
2996 bfd_put_32 (output_bfd
, 0,
2997 htab
->sgotplt
->contents
+ offplt
2998 + htab
->sgotplt_jump_table_size
+ 4);
3002 sreloc
= htab
->srelgot
;
3004 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3005 + htab
->sgot
->output_offset
+ off
);
3007 if (GOT_TLS_GD_P (tls_type
))
3008 dr_type
= R_386_TLS_DTPMOD32
;
3009 else if (GOT_TLS_GDESC_P (tls_type
))
3011 else if (tls_type
== GOT_TLS_IE_POS
)
3012 dr_type
= R_386_TLS_TPOFF
;
3014 dr_type
= R_386_TLS_TPOFF32
;
3016 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
3017 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
3018 htab
->sgot
->contents
+ off
);
3019 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
3020 bfd_put_32 (output_bfd
, dtpoff_base (info
) - relocation
,
3021 htab
->sgot
->contents
+ off
);
3022 else if (dr_type
!= R_386_TLS_DESC
)
3023 bfd_put_32 (output_bfd
, 0,
3024 htab
->sgot
->contents
+ off
);
3025 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
3027 loc
= sreloc
->contents
;
3028 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3029 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3030 <= sreloc
->contents
+ sreloc
->size
);
3031 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3033 if (GOT_TLS_GD_P (tls_type
))
3037 BFD_ASSERT (! unresolved_reloc
);
3038 bfd_put_32 (output_bfd
,
3039 relocation
- dtpoff_base (info
),
3040 htab
->sgot
->contents
+ off
+ 4);
3044 bfd_put_32 (output_bfd
, 0,
3045 htab
->sgot
->contents
+ off
+ 4);
3046 outrel
.r_info
= ELF32_R_INFO (indx
,
3047 R_386_TLS_DTPOFF32
);
3048 outrel
.r_offset
+= 4;
3049 sreloc
->reloc_count
++;
3050 loc
+= sizeof (Elf32_External_Rel
);
3051 BFD_ASSERT (loc
+ sizeof (Elf32_External_Rel
)
3052 <= sreloc
->contents
+ sreloc
->size
);
3053 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3056 else if (tls_type
== GOT_TLS_IE_BOTH
)
3058 bfd_put_32 (output_bfd
,
3059 indx
== 0 ? relocation
- dtpoff_base (info
) : 0,
3060 htab
->sgot
->contents
+ off
+ 4);
3061 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3062 outrel
.r_offset
+= 4;
3063 sreloc
->reloc_count
++;
3064 loc
+= sizeof (Elf32_External_Rel
);
3065 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3072 local_got_offsets
[r_symndx
] |= 1;
3075 if (off
>= (bfd_vma
) -2
3076 && ! GOT_TLS_GDESC_P (tls_type
))
3078 if (r_type
== R_386_TLS_GOTDESC
3079 || r_type
== R_386_TLS_DESC_CALL
)
3081 relocation
= htab
->sgotplt_jump_table_size
+ offplt
;
3082 unresolved_reloc
= FALSE
;
3084 else if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3086 bfd_vma g_o_t
= htab
->sgotplt
->output_section
->vma
3087 + htab
->sgotplt
->output_offset
;
3088 relocation
= htab
->sgot
->output_section
->vma
3089 + htab
->sgot
->output_offset
+ off
- g_o_t
;
3090 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
3091 && tls_type
== GOT_TLS_IE_BOTH
)
3093 if (r_type
== R_386_TLS_IE
)
3094 relocation
+= g_o_t
;
3095 unresolved_reloc
= FALSE
;
3097 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
3099 unsigned int val
, type
;
3102 /* GD->IE transition. */
3103 BFD_ASSERT (rel
->r_offset
>= 2);
3104 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
3105 BFD_ASSERT (type
== 0x8d || type
== 0x04);
3106 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3107 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3109 BFD_ASSERT (rel
+ 1 < relend
);
3110 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3111 roff
= rel
->r_offset
- 3;
3112 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3115 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3117 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3118 BFD_ASSERT (rel
->r_offset
>= 3);
3119 BFD_ASSERT (bfd_get_8 (input_bfd
,
3120 contents
+ rel
->r_offset
- 3)
3122 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
3127 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3129 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3130 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->size
);
3131 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3132 BFD_ASSERT (bfd_get_8 (input_bfd
,
3133 contents
+ rel
->r_offset
+ 9)
3135 roff
= rel
->r_offset
- 2;
3137 memcpy (contents
+ roff
,
3138 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3139 contents
[roff
+ 7] = 0x80 | (val
& 7);
3140 /* If foo is used only with foo@gotntpoff(%reg) and
3141 foo@indntpoff, but not with foo@gottpoff(%reg), change
3142 subl $foo@gottpoff(%reg), %eax
3144 addl $foo@gotntpoff(%reg), %eax. */
3145 if (tls_type
== GOT_TLS_IE_POS
)
3146 contents
[roff
+ 6] = 0x03;
3147 bfd_put_32 (output_bfd
,
3148 htab
->sgot
->output_section
->vma
3149 + htab
->sgot
->output_offset
+ off
3150 - htab
->sgotplt
->output_section
->vma
3151 - htab
->sgotplt
->output_offset
,
3152 contents
+ roff
+ 8);
3153 /* Skip R_386_PLT32. */
3157 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTDESC
)
3159 /* GDesc -> IE transition.
3160 It's originally something like:
3161 leal x@tlsdesc(%ebx), %eax
3164 movl x@gotntpoff(%ebx), %eax # before nop; nop
3166 movl x@gottpoff(%ebx), %eax # before negl %eax
3168 Registers other than %eax may be set up here. */
3170 unsigned int val
, type
;
3173 /* First, make sure it's a leal adding ebx to a 32-bit
3174 offset into any register, although it's probably
3175 almost always going to be eax. */
3176 roff
= rel
->r_offset
;
3177 BFD_ASSERT (roff
>= 2);
3178 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3179 BFD_ASSERT (type
== 0x8d);
3180 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3181 BFD_ASSERT ((val
& 0xc7) == 0x83);
3182 BFD_ASSERT (roff
+ 4 <= input_section
->size
);
3184 /* Now modify the instruction as appropriate. */
3185 /* To turn a leal into a movl in the form we use it, it
3186 suffices to change the first byte from 0x8d to 0x8b.
3187 aoliva FIXME: should we decide to keep the leal, all
3188 we have to do is remove the statement below, and
3189 adjust the relaxation of R_386_TLS_DESC_CALL. */
3190 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3192 if (tls_type
== GOT_TLS_IE_BOTH
)
3195 bfd_put_32 (output_bfd
,
3196 htab
->sgot
->output_section
->vma
3197 + htab
->sgot
->output_offset
+ off
3198 - htab
->sgotplt
->output_section
->vma
3199 - htab
->sgotplt
->output_offset
,
3203 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_DESC_CALL
)
3205 /* GDesc -> IE transition.
3213 depending on how we transformed the TLS_GOTDESC above.
3216 unsigned int val
, type
;
3219 /* First, make sure it's a call *(%eax). */
3220 roff
= rel
->r_offset
;
3221 BFD_ASSERT (roff
+ 2 <= input_section
->size
);
3222 type
= bfd_get_8 (input_bfd
, contents
+ roff
);
3223 BFD_ASSERT (type
== 0xff);
3224 val
= bfd_get_8 (input_bfd
, contents
+ roff
+ 1);
3225 BFD_ASSERT (val
== 0x10);
3227 /* Now modify the instruction as appropriate. */
3228 if (tls_type
!= GOT_TLS_IE_NEG
)
3231 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
);
3232 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3237 bfd_put_8 (output_bfd
, 0xf7, contents
+ roff
);
3238 bfd_put_8 (output_bfd
, 0xd8, contents
+ roff
+ 1);
3252 /* LD->LE transition:
3254 leal foo(%reg), %eax; call ___tls_get_addr.
3256 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
3257 BFD_ASSERT (rel
->r_offset
>= 2);
3258 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
3260 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
3261 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
3262 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
3263 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
3265 BFD_ASSERT (rel
+ 1 < relend
);
3266 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
3267 memcpy (contents
+ rel
->r_offset
- 2,
3268 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3269 /* Skip R_386_PLT32. */
3274 if (htab
->sgot
== NULL
)
3277 off
= htab
->tls_ldm_got
.offset
;
3282 Elf_Internal_Rela outrel
;
3285 if (htab
->srelgot
== NULL
)
3288 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3289 + htab
->sgot
->output_offset
+ off
);
3291 bfd_put_32 (output_bfd
, 0,
3292 htab
->sgot
->contents
+ off
);
3293 bfd_put_32 (output_bfd
, 0,
3294 htab
->sgot
->contents
+ off
+ 4);
3295 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
3296 loc
= htab
->srelgot
->contents
;
3297 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3298 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3299 htab
->tls_ldm_got
.offset
|= 1;
3301 relocation
= htab
->sgot
->output_section
->vma
3302 + htab
->sgot
->output_offset
+ off
3303 - htab
->sgotplt
->output_section
->vma
3304 - htab
->sgotplt
->output_offset
;
3305 unresolved_reloc
= FALSE
;
3308 case R_386_TLS_LDO_32
:
3309 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
3310 relocation
-= dtpoff_base (info
);
3312 /* When converting LDO to LE, we must negate. */
3313 relocation
= -tpoff (info
, relocation
);
3316 case R_386_TLS_LE_32
:
3320 Elf_Internal_Rela outrel
;
3325 outrel
.r_offset
= rel
->r_offset
3326 + input_section
->output_section
->vma
3327 + input_section
->output_offset
;
3328 if (h
!= NULL
&& h
->dynindx
!= -1)
3332 if (r_type
== R_386_TLS_LE_32
)
3333 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
3335 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
3336 sreloc
= elf_section_data (input_section
)->sreloc
;
3339 loc
= sreloc
->contents
;
3340 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3341 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
3344 else if (r_type
== R_386_TLS_LE_32
)
3345 relocation
= dtpoff_base (info
) - relocation
;
3347 relocation
-= dtpoff_base (info
);
3349 else if (r_type
== R_386_TLS_LE_32
)
3350 relocation
= tpoff (info
, relocation
);
3352 relocation
= -tpoff (info
, relocation
);
3359 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3360 because such sections are not SEC_ALLOC and thus ld.so will
3361 not process them. */
3362 if (unresolved_reloc
3363 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3366 (*_bfd_error_handler
)
3367 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3370 (long) rel
->r_offset
,
3372 h
->root
.root
.string
);
3376 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3377 contents
, rel
->r_offset
,
3380 if (r
!= bfd_reloc_ok
)
3385 name
= h
->root
.root
.string
;
3388 name
= bfd_elf_string_from_elf_section (input_bfd
,
3389 symtab_hdr
->sh_link
,
3394 name
= bfd_section_name (input_bfd
, sec
);
3397 if (r
== bfd_reloc_overflow
)
3399 if (! ((*info
->callbacks
->reloc_overflow
)
3400 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3401 (bfd_vma
) 0, input_bfd
, input_section
,
3407 (*_bfd_error_handler
)
3408 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3409 input_bfd
, input_section
,
3410 (long) rel
->r_offset
, name
, (int) r
);
3419 /* Finish up dynamic symbol handling. We set the contents of various
3420 dynamic sections here. */
3423 elf_i386_finish_dynamic_symbol (bfd
*output_bfd
,
3424 struct bfd_link_info
*info
,
3425 struct elf_link_hash_entry
*h
,
3426 Elf_Internal_Sym
*sym
)
3428 struct elf_i386_link_hash_table
*htab
;
3430 htab
= elf_i386_hash_table (info
);
3432 if (h
->plt
.offset
!= (bfd_vma
) -1)
3436 Elf_Internal_Rela rel
;
3439 /* This symbol has an entry in the procedure linkage table. Set
3442 if (h
->dynindx
== -1
3443 || htab
->splt
== NULL
3444 || htab
->sgotplt
== NULL
3445 || htab
->srelplt
== NULL
)
3448 /* Get the index in the procedure linkage table which
3449 corresponds to this symbol. This is the index of this symbol
3450 in all the symbols for which we are making plt entries. The
3451 first entry in the procedure linkage table is reserved. */
3452 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3454 /* Get the offset into the .got table of the entry that
3455 corresponds to this function. Each .got entry is 4 bytes.
3456 The first three are reserved. */
3457 got_offset
= (plt_index
+ 3) * 4;
3459 /* Fill in the entry in the procedure linkage table. */
3462 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
3464 bfd_put_32 (output_bfd
,
3465 (htab
->sgotplt
->output_section
->vma
3466 + htab
->sgotplt
->output_offset
3468 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3470 if (htab
->is_vxworks
)
3472 int s
, k
, reloc_index
;
3474 /* Create the R_386_32 relocation referencing the GOT
3475 for this PLT entry. */
3477 /* S: Current slot number (zero-based). */
3478 s
= (h
->plt
.offset
- PLT_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
3479 /* K: Number of relocations for PLTResolve. */
3481 k
= PLTRESOLVE_RELOCS_SHLIB
;
3483 k
= PLTRESOLVE_RELOCS
;
3484 /* Skip the PLTresolve relocations, and the relocations for
3485 the other PLT slots. */
3486 reloc_index
= k
+ s
* PLT_NON_JUMP_SLOT_RELOCS
;
3487 loc
= (htab
->srelplt2
->contents
+ reloc_index
3488 * sizeof (Elf32_External_Rel
));
3490 rel
.r_offset
= (htab
->splt
->output_section
->vma
3491 + htab
->splt
->output_offset
3492 + h
->plt
.offset
+ 2),
3493 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3494 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3496 /* Create the R_386_32 relocation referencing the beginning of
3497 the PLT for this GOT entry. */
3498 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3499 + htab
->sgotplt
->output_offset
3501 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
3502 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3503 loc
+ sizeof (Elf32_External_Rel
));
3508 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
3510 bfd_put_32 (output_bfd
, got_offset
,
3511 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3514 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
3515 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
3516 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
3517 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
3519 /* Fill in the entry in the global offset table. */
3520 bfd_put_32 (output_bfd
,
3521 (htab
->splt
->output_section
->vma
3522 + htab
->splt
->output_offset
3525 htab
->sgotplt
->contents
+ got_offset
);
3527 /* Fill in the entry in the .rel.plt section. */
3528 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3529 + htab
->sgotplt
->output_offset
3531 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
3532 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3533 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3535 if (!h
->def_regular
)
3537 /* Mark the symbol as undefined, rather than as defined in
3538 the .plt section. Leave the value if there were any
3539 relocations where pointer equality matters (this is a clue
3540 for the dynamic linker, to make function pointer
3541 comparisons work between an application and shared
3542 library), otherwise set it to zero. If a function is only
3543 called from a binary, there is no need to slow down
3544 shared libraries because of that. */
3545 sym
->st_shndx
= SHN_UNDEF
;
3546 if (!h
->pointer_equality_needed
)
3551 if (h
->got
.offset
!= (bfd_vma
) -1
3552 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h
)->tls_type
)
3553 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
3555 Elf_Internal_Rela rel
;
3558 /* This symbol has an entry in the global offset table. Set it
3561 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
3564 rel
.r_offset
= (htab
->sgot
->output_section
->vma
3565 + htab
->sgot
->output_offset
3566 + (h
->got
.offset
& ~(bfd_vma
) 1));
3568 /* If this is a static link, or it is a -Bsymbolic link and the
3569 symbol is defined locally or was forced to be local because
3570 of a version file, we just want to emit a RELATIVE reloc.
3571 The entry in the global offset table will already have been
3572 initialized in the relocate_section function. */
3574 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3576 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3577 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3581 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3582 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
3583 htab
->sgot
->contents
+ h
->got
.offset
);
3584 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
3587 loc
= htab
->srelgot
->contents
;
3588 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3589 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3594 Elf_Internal_Rela rel
;
3597 /* This symbol needs a copy reloc. Set it up. */
3599 if (h
->dynindx
== -1
3600 || (h
->root
.type
!= bfd_link_hash_defined
3601 && h
->root
.type
!= bfd_link_hash_defweak
)
3602 || htab
->srelbss
== NULL
)
3605 rel
.r_offset
= (h
->root
.u
.def
.value
3606 + h
->root
.u
.def
.section
->output_section
->vma
3607 + h
->root
.u
.def
.section
->output_offset
);
3608 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
3609 loc
= htab
->srelbss
->contents
;
3610 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3611 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3614 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3615 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3616 is relative to the ".got" section. */
3617 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3618 || (!htab
->is_vxworks
&& h
== htab
->elf
.hgot
))
3619 sym
->st_shndx
= SHN_ABS
;
3624 /* Used to decide how to sort relocs in an optimal manner for the
3625 dynamic linker, before writing them out. */
3627 static enum elf_reloc_type_class
3628 elf_i386_reloc_type_class (const Elf_Internal_Rela
*rela
)
3630 switch (ELF32_R_TYPE (rela
->r_info
))
3632 case R_386_RELATIVE
:
3633 return reloc_class_relative
;
3634 case R_386_JUMP_SLOT
:
3635 return reloc_class_plt
;
3637 return reloc_class_copy
;
3639 return reloc_class_normal
;
3643 /* Finish up the dynamic sections. */
3646 elf_i386_finish_dynamic_sections (bfd
*output_bfd
,
3647 struct bfd_link_info
*info
)
3649 struct elf_i386_link_hash_table
*htab
;
3653 htab
= elf_i386_hash_table (info
);
3654 dynobj
= htab
->elf
.dynobj
;
3655 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3657 if (htab
->elf
.dynamic_sections_created
)
3659 Elf32_External_Dyn
*dyncon
, *dynconend
;
3661 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3664 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3665 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3666 for (; dyncon
< dynconend
; dyncon
++)
3668 Elf_Internal_Dyn dyn
;
3671 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3680 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3685 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3690 dyn
.d_un
.d_val
= s
->size
;
3694 /* My reading of the SVR4 ABI indicates that the
3695 procedure linkage table relocs (DT_JMPREL) should be
3696 included in the overall relocs (DT_REL). This is
3697 what Solaris does. However, UnixWare can not handle
3698 that case. Therefore, we override the DT_RELSZ entry
3699 here to make it not include the JMPREL relocs. */
3703 dyn
.d_un
.d_val
-= s
->size
;
3707 /* We may not be using the standard ELF linker script.
3708 If .rel.plt is the first .rel section, we adjust
3709 DT_REL to not include it. */
3713 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
3715 dyn
.d_un
.d_ptr
+= s
->size
;
3719 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3722 /* Fill in the first entry in the procedure linkage table. */
3723 if (htab
->splt
&& htab
->splt
->size
> 0)
3727 memcpy (htab
->splt
->contents
, elf_i386_pic_plt0_entry
,
3728 sizeof (elf_i386_pic_plt0_entry
));
3729 memset (htab
->splt
->contents
+ sizeof (elf_i386_pic_plt0_entry
),
3730 htab
->plt0_pad_byte
,
3731 PLT_ENTRY_SIZE
- sizeof (elf_i386_pic_plt0_entry
));
3735 memcpy (htab
->splt
->contents
, elf_i386_plt0_entry
,
3736 sizeof(elf_i386_plt0_entry
));
3737 memset (htab
->splt
->contents
+ sizeof (elf_i386_plt0_entry
),
3738 htab
->plt0_pad_byte
,
3739 PLT_ENTRY_SIZE
- sizeof (elf_i386_plt0_entry
));
3740 bfd_put_32 (output_bfd
,
3741 (htab
->sgotplt
->output_section
->vma
3742 + htab
->sgotplt
->output_offset
3744 htab
->splt
->contents
+ 2);
3745 bfd_put_32 (output_bfd
,
3746 (htab
->sgotplt
->output_section
->vma
3747 + htab
->sgotplt
->output_offset
3749 htab
->splt
->contents
+ 8);
3751 if (htab
->is_vxworks
)
3753 Elf_Internal_Rela rel
;
3755 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3756 On IA32 we use REL relocations so the addend goes in
3757 the PLT directly. */
3758 rel
.r_offset
= (htab
->splt
->output_section
->vma
3759 + htab
->splt
->output_offset
3761 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3762 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3763 htab
->srelplt2
->contents
);
3764 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
3765 rel
.r_offset
= (htab
->splt
->output_section
->vma
3766 + htab
->splt
->output_offset
3768 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3769 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3770 htab
->srelplt2
->contents
+
3771 sizeof (Elf32_External_Rel
));
3775 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3776 really seem like the right value. */
3777 elf_section_data (htab
->splt
->output_section
)
3778 ->this_hdr
.sh_entsize
= 4;
3780 /* Correct the .rel.plt.unloaded relocations. */
3781 if (htab
->is_vxworks
&& !info
->shared
)
3783 int num_plts
= (htab
->splt
->size
/ PLT_ENTRY_SIZE
) - 1;
3786 p
= htab
->srelplt2
->contents
;
3788 p
+= PLTRESOLVE_RELOCS_SHLIB
* sizeof (Elf32_External_Rel
);
3790 p
+= PLTRESOLVE_RELOCS
* sizeof (Elf32_External_Rel
);
3792 for (; num_plts
; num_plts
--)
3794 Elf_Internal_Rela rel
;
3795 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3796 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_386_32
);
3797 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3798 p
+= sizeof (Elf32_External_Rel
);
3800 bfd_elf32_swap_reloc_in (output_bfd
, p
, &rel
);
3801 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_386_32
);
3802 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, p
);
3803 p
+= sizeof (Elf32_External_Rel
);
3811 /* Fill in the first three entries in the global offset table. */
3812 if (htab
->sgotplt
->size
> 0)
3814 bfd_put_32 (output_bfd
,
3816 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3817 htab
->sgotplt
->contents
);
3818 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 4);
3819 bfd_put_32 (output_bfd
, 0, htab
->sgotplt
->contents
+ 8);
3822 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3825 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3826 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3831 /* Return address for Ith PLT stub in section PLT, for relocation REL
3832 or (bfd_vma) -1 if it should not be included. */
3835 elf_i386_plt_sym_val (bfd_vma i
, const asection
*plt
,
3836 const arelent
*rel ATTRIBUTE_UNUSED
)
3838 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
3842 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3843 #define TARGET_LITTLE_NAME "elf32-i386"
3844 #define ELF_ARCH bfd_arch_i386
3845 #define ELF_MACHINE_CODE EM_386
3846 #define ELF_MAXPAGESIZE 0x1000
3848 #define elf_backend_can_gc_sections 1
3849 #define elf_backend_can_refcount 1
3850 #define elf_backend_want_got_plt 1
3851 #define elf_backend_plt_readonly 1
3852 #define elf_backend_want_plt_sym 0
3853 #define elf_backend_got_header_size 12
3855 /* Support RELA for objdump of prelink objects. */
3856 #define elf_info_to_howto elf_i386_info_to_howto_rel
3857 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3859 #define bfd_elf32_mkobject elf_i386_mkobject
3861 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3862 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3863 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3865 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3866 #define elf_backend_check_relocs elf_i386_check_relocs
3867 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3868 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3869 #define elf_backend_fake_sections elf_i386_fake_sections
3870 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3871 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3872 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3873 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3874 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3875 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3876 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3877 #define elf_backend_relocate_section elf_i386_relocate_section
3878 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3879 #define elf_backend_always_size_sections elf_i386_always_size_sections
3880 #define elf_backend_plt_sym_val elf_i386_plt_sym_val
3882 #include "elf32-target.h"
3884 /* FreeBSD support. */
3886 #undef TARGET_LITTLE_SYM
3887 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3888 #undef TARGET_LITTLE_NAME
3889 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3891 /* The kernel recognizes executables as valid only if they carry a
3892 "FreeBSD" label in the ELF header. So we put this label on all
3893 executables and (for simplicity) also all other object files. */
3896 elf_i386_post_process_headers (bfd
*abfd
,
3897 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3899 Elf_Internal_Ehdr
*i_ehdrp
;
3901 i_ehdrp
= elf_elfheader (abfd
);
3903 /* Put an ABI label supported by FreeBSD >= 4.1. */
3904 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
3905 #ifdef OLD_FREEBSD_ABI_LABEL
3906 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3907 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
3911 #undef elf_backend_post_process_headers
3912 #define elf_backend_post_process_headers elf_i386_post_process_headers
3914 #define elf32_bed elf32_i386_fbsd_bed
3916 #include "elf32-target.h"
3918 /* VxWorks support. */
3920 #undef TARGET_LITTLE_SYM
3921 #define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
3922 #undef TARGET_LITTLE_NAME
3923 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
3926 /* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
3928 static struct bfd_link_hash_table
*
3929 elf_i386_vxworks_link_hash_table_create (bfd
*abfd
)
3931 struct bfd_link_hash_table
*ret
;
3932 struct elf_i386_link_hash_table
*htab
;
3934 ret
= elf_i386_link_hash_table_create (abfd
);
3937 htab
= (struct elf_i386_link_hash_table
*) ret
;
3938 htab
->is_vxworks
= 1;
3939 htab
->plt0_pad_byte
= 0x90;
3946 #undef elf_backend_post_process_headers
3947 #undef bfd_elf32_bfd_link_hash_table_create
3948 #define bfd_elf32_bfd_link_hash_table_create \
3949 elf_i386_vxworks_link_hash_table_create
3950 #undef elf_backend_add_symbol_hook
3951 #define elf_backend_add_symbol_hook \
3952 elf_vxworks_add_symbol_hook
3953 #undef elf_backend_link_output_symbol_hook
3954 #define elf_backend_link_output_symbol_hook \
3955 elf_vxworks_link_output_symbol_hook
3956 #undef elf_backend_emit_relocs
3957 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
3958 #undef elf_backend_final_write_processing
3959 #define elf_backend_final_write_processing \
3960 elf_vxworks_final_write_processing
3962 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3964 #undef elf_backend_want_plt_sym
3965 #define elf_backend_want_plt_sym 1
3968 #define elf32_bed elf32_i386_vxworks_bed
3970 #include "elf32-target.h"