]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-i386.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix performance regression on x86 with ld -r
[thirdparty/binutils-gdb.git] / bfd / elf32-i386.c
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2015 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf-nacl.h"
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
29 #include "objalloc.h"
30 #include "hashtab.h"
31 #include "dwarf2.h"
32 #include "opcode/i386.h"
33
34 /* 386 uses REL relocations instead of RELA. */
35 #define USE_REL 1
36
37 #include "elf/i386.h"
38
39 static reloc_howto_type elf_howto_table[]=
40 {
41 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
42 bfd_elf_generic_reloc, "R_386_NONE",
43 TRUE, 0x00000000, 0x00000000, FALSE),
44 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
45 bfd_elf_generic_reloc, "R_386_32",
46 TRUE, 0xffffffff, 0xffffffff, FALSE),
47 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
48 bfd_elf_generic_reloc, "R_386_PC32",
49 TRUE, 0xffffffff, 0xffffffff, TRUE),
50 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
51 bfd_elf_generic_reloc, "R_386_GOT32",
52 TRUE, 0xffffffff, 0xffffffff, FALSE),
53 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
54 bfd_elf_generic_reloc, "R_386_PLT32",
55 TRUE, 0xffffffff, 0xffffffff, TRUE),
56 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
57 bfd_elf_generic_reloc, "R_386_COPY",
58 TRUE, 0xffffffff, 0xffffffff, FALSE),
59 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
60 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
61 TRUE, 0xffffffff, 0xffffffff, FALSE),
62 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
64 TRUE, 0xffffffff, 0xffffffff, FALSE),
65 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
66 bfd_elf_generic_reloc, "R_386_RELATIVE",
67 TRUE, 0xffffffff, 0xffffffff, FALSE),
68 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
69 bfd_elf_generic_reloc, "R_386_GOTOFF",
70 TRUE, 0xffffffff, 0xffffffff, FALSE),
71 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
72 bfd_elf_generic_reloc, "R_386_GOTPC",
73 TRUE, 0xffffffff, 0xffffffff, TRUE),
74
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
81
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
85 TRUE, 0xffffffff, 0xffffffff, FALSE),
86 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_386_TLS_IE",
88 TRUE, 0xffffffff, 0xffffffff, FALSE),
89 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
90 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
91 TRUE, 0xffffffff, 0xffffffff, FALSE),
92 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_386_TLS_LE",
94 TRUE, 0xffffffff, 0xffffffff, FALSE),
95 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_386_TLS_GD",
97 TRUE, 0xffffffff, 0xffffffff, FALSE),
98 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_386_TLS_LDM",
100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_386_16",
103 TRUE, 0xffff, 0xffff, FALSE),
104 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_386_PC16",
106 TRUE, 0xffff, 0xffff, TRUE),
107 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_386_8",
109 TRUE, 0xff, 0xff, FALSE),
110 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_386_PC8",
112 TRUE, 0xff, 0xff, TRUE),
113
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
119 TRUE, 0xffffffff, 0xffffffff, FALSE),
120 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
122 TRUE, 0xffffffff, 0xffffffff, FALSE),
123 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
124 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
125 TRUE, 0xffffffff, 0xffffffff, FALSE),
126 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
128 TRUE, 0xffffffff, 0xffffffff, FALSE),
129 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
131 TRUE, 0xffffffff, 0xffffffff, FALSE),
132 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
133 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
134 TRUE, 0xffffffff, 0xffffffff, FALSE),
135 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
136 bfd_elf_generic_reloc, "R_386_SIZE32",
137 TRUE, 0xffffffff, 0xffffffff, FALSE),
138 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
142 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
143 FALSE, 0, 0, FALSE),
144 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_DESC",
146 TRUE, 0xffffffff, 0xffffffff, FALSE),
147 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_IRELATIVE",
149 TRUE, 0xffffffff, 0xffffffff, FALSE),
150 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_GOT32X",
152 TRUE, 0xffffffff, 0xffffffff, FALSE),
153
154 /* Another gap. */
155 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
156 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
157
158 /* GNU extension to record C++ vtable hierarchy. */
159 HOWTO (R_386_GNU_VTINHERIT, /* type */
160 0, /* rightshift */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
162 0, /* bitsize */
163 FALSE, /* pc_relative */
164 0, /* bitpos */
165 complain_overflow_dont, /* complain_on_overflow */
166 NULL, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
168 FALSE, /* partial_inplace */
169 0, /* src_mask */
170 0, /* dst_mask */
171 FALSE), /* pcrel_offset */
172
173 /* GNU extension to record C++ vtable member usage. */
174 HOWTO (R_386_GNU_VTENTRY, /* type */
175 0, /* rightshift */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
177 0, /* bitsize */
178 FALSE, /* pc_relative */
179 0, /* bitpos */
180 complain_overflow_dont, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
183 FALSE, /* partial_inplace */
184 0, /* src_mask */
185 0, /* dst_mask */
186 FALSE) /* pcrel_offset */
187
188 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
189
190 };
191
192 #ifdef DEBUG_GEN_RELOC
193 #define TRACE(str) \
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
195 #else
196 #define TRACE(str)
197 #endif
198
199 static reloc_howto_type *
200 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
201 bfd_reloc_code_real_type code)
202 {
203 switch (code)
204 {
205 case BFD_RELOC_NONE:
206 TRACE ("BFD_RELOC_NONE");
207 return &elf_howto_table[R_386_NONE];
208
209 case BFD_RELOC_32:
210 TRACE ("BFD_RELOC_32");
211 return &elf_howto_table[R_386_32];
212
213 case BFD_RELOC_CTOR:
214 TRACE ("BFD_RELOC_CTOR");
215 return &elf_howto_table[R_386_32];
216
217 case BFD_RELOC_32_PCREL:
218 TRACE ("BFD_RELOC_PC32");
219 return &elf_howto_table[R_386_PC32];
220
221 case BFD_RELOC_386_GOT32:
222 TRACE ("BFD_RELOC_386_GOT32");
223 return &elf_howto_table[R_386_GOT32];
224
225 case BFD_RELOC_386_PLT32:
226 TRACE ("BFD_RELOC_386_PLT32");
227 return &elf_howto_table[R_386_PLT32];
228
229 case BFD_RELOC_386_COPY:
230 TRACE ("BFD_RELOC_386_COPY");
231 return &elf_howto_table[R_386_COPY];
232
233 case BFD_RELOC_386_GLOB_DAT:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
235 return &elf_howto_table[R_386_GLOB_DAT];
236
237 case BFD_RELOC_386_JUMP_SLOT:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
239 return &elf_howto_table[R_386_JUMP_SLOT];
240
241 case BFD_RELOC_386_RELATIVE:
242 TRACE ("BFD_RELOC_386_RELATIVE");
243 return &elf_howto_table[R_386_RELATIVE];
244
245 case BFD_RELOC_386_GOTOFF:
246 TRACE ("BFD_RELOC_386_GOTOFF");
247 return &elf_howto_table[R_386_GOTOFF];
248
249 case BFD_RELOC_386_GOTPC:
250 TRACE ("BFD_RELOC_386_GOTPC");
251 return &elf_howto_table[R_386_GOTPC];
252
253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
256 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
257
258 case BFD_RELOC_386_TLS_IE:
259 TRACE ("BFD_RELOC_386_TLS_IE");
260 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
261
262 case BFD_RELOC_386_TLS_GOTIE:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
264 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
265
266 case BFD_RELOC_386_TLS_LE:
267 TRACE ("BFD_RELOC_386_TLS_LE");
268 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
269
270 case BFD_RELOC_386_TLS_GD:
271 TRACE ("BFD_RELOC_386_TLS_GD");
272 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
273
274 case BFD_RELOC_386_TLS_LDM:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
276 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
277
278 case BFD_RELOC_16:
279 TRACE ("BFD_RELOC_16");
280 return &elf_howto_table[R_386_16 - R_386_ext_offset];
281
282 case BFD_RELOC_16_PCREL:
283 TRACE ("BFD_RELOC_16_PCREL");
284 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
285
286 case BFD_RELOC_8:
287 TRACE ("BFD_RELOC_8");
288 return &elf_howto_table[R_386_8 - R_386_ext_offset];
289
290 case BFD_RELOC_8_PCREL:
291 TRACE ("BFD_RELOC_8_PCREL");
292 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
293
294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
297 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
298
299 case BFD_RELOC_386_TLS_IE_32:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
301 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
302
303 case BFD_RELOC_386_TLS_LE_32:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
305 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
306
307 case BFD_RELOC_386_TLS_DTPMOD32:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
309 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
310
311 case BFD_RELOC_386_TLS_DTPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
313 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
314
315 case BFD_RELOC_386_TLS_TPOFF32:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
317 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
318
319 case BFD_RELOC_SIZE32:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
322
323 case BFD_RELOC_386_TLS_GOTDESC:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
326
327 case BFD_RELOC_386_TLS_DESC_CALL:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
330
331 case BFD_RELOC_386_TLS_DESC:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
334
335 case BFD_RELOC_386_IRELATIVE:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
337 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
338
339 case BFD_RELOC_386_GOT32X:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
342
343 case BFD_RELOC_VTABLE_INHERIT:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
345 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
346
347 case BFD_RELOC_VTABLE_ENTRY:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
349 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
350
351 default:
352 break;
353 }
354
355 TRACE ("Unknown");
356 return 0;
357 }
358
359 static reloc_howto_type *
360 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
361 const char *r_name)
362 {
363 unsigned int i;
364
365 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
366 if (elf_howto_table[i].name != NULL
367 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
368 return &elf_howto_table[i];
369
370 return NULL;
371 }
372
373 static reloc_howto_type *
374 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
375 {
376 unsigned int indx;
377
378 if ((indx = r_type) >= R_386_standard
379 && ((indx = r_type - R_386_ext_offset) - R_386_standard
380 >= R_386_ext - R_386_standard)
381 && ((indx = r_type - R_386_tls_offset) - R_386_ext
382 >= R_386_ext2 - R_386_ext)
383 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
384 >= R_386_vt - R_386_ext2))
385 {
386 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
387 abfd, (int) r_type);
388 indx = R_386_NONE;
389 }
390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table [indx].type != r_type)
392 return NULL;
393 return &elf_howto_table[indx];
394 }
395
396 static void
397 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
398 arelent *cache_ptr,
399 Elf_Internal_Rela *dst)
400 {
401 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
402 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
403 }
404
405 /* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
410
411 static bfd_boolean
412 elf_i386_is_local_label_name (bfd *abfd, const char *name)
413 {
414 if (name[0] == '.' && name[1] == 'X')
415 return TRUE;
416
417 return _bfd_elf_is_local_label_name (abfd, name);
418 }
419 \f
420 /* Support for core dump NOTE sections. */
421
422 static bfd_boolean
423 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
424 {
425 int offset;
426 size_t size;
427
428 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
429 {
430 int pr_version = bfd_get_32 (abfd, note->descdata);
431
432 if (pr_version != 1)
433 return FALSE;
434
435 /* pr_cursig */
436 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
437
438 /* pr_pid */
439 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
440
441 /* pr_reg */
442 offset = 28;
443 size = bfd_get_32 (abfd, note->descdata + 8);
444 }
445 else
446 {
447 switch (note->descsz)
448 {
449 default:
450 return FALSE;
451
452 case 144: /* Linux/i386 */
453 /* pr_cursig */
454 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
455
456 /* pr_pid */
457 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
458
459 /* pr_reg */
460 offset = 72;
461 size = 68;
462
463 break;
464 }
465 }
466
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
469 size, note->descpos + offset);
470 }
471
472 static bfd_boolean
473 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
474 {
475 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
476 {
477 int pr_version = bfd_get_32 (abfd, note->descdata);
478
479 if (pr_version != 1)
480 return FALSE;
481
482 elf_tdata (abfd)->core->program
483 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
484 elf_tdata (abfd)->core->command
485 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
486 }
487 else
488 {
489 switch (note->descsz)
490 {
491 default:
492 return FALSE;
493
494 case 124: /* Linux/i386 elf_prpsinfo. */
495 elf_tdata (abfd)->core->pid
496 = bfd_get_32 (abfd, note->descdata + 12);
497 elf_tdata (abfd)->core->program
498 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
499 elf_tdata (abfd)->core->command
500 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
501 }
502 }
503
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
507 {
508 char *command = elf_tdata (abfd)->core->command;
509 int n = strlen (command);
510
511 if (0 < n && command[n - 1] == ' ')
512 command[n - 1] = '\0';
513 }
514
515 return TRUE;
516 }
517 \f
518 /* Functions for the i386 ELF linker.
519
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
522 following:
523
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
530
531
532 /* The name of the dynamic interpreter. This is put in the .interp
533 section. */
534
535 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
536
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
540 shared lib. */
541 #define ELIMINATE_COPY_RELOCS 1
542
543 /* The size in bytes of an entry in the procedure linkage table. */
544
545 #define PLT_ENTRY_SIZE 16
546
547 /* The first entry in an absolute procedure linkage table looks like
548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
550
551 static const bfd_byte elf_i386_plt0_entry[12] =
552 {
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0 /* replaced with address of .got + 8. */
557 };
558
559 /* Subsequent entries in an absolute procedure linkage table look like
560 this. */
561
562 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
563 {
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
570 };
571
572 /* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
574
575 static const bfd_byte elf_i386_pic_plt0_entry[12] =
576 {
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
579 };
580
581 /* Subsequent entries in a PIC procedure linkage table look like this. */
582
583 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
584 {
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
591 };
592
593 /* Entries in the GOT procedure linkage table look like this. */
594
595 static const bfd_byte elf_i386_got_plt_entry[8] =
596 {
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
600 };
601
602 /* Entries in the PIC GOT procedure linkage table look like this. */
603
604 static const bfd_byte elf_i386_pic_got_plt_entry[8] =
605 {
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
609 };
610
611 /* .eh_frame covering the .plt section. */
612
613 static const bfd_byte elf_i386_eh_frame_plt[] =
614 {
615 #define PLT_CIE_LENGTH 20
616 #define PLT_FDE_LENGTH 36
617 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
621 1, /* CIE version */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
628 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop, DW_CFA_nop,
631
632 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
646 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
647 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
648 };
649
650 struct elf_i386_plt_layout
651 {
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte *plt0_entry;
654 unsigned int plt0_entry_size;
655
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset;
658 unsigned int plt0_got2_offset;
659
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte *plt_entry;
662 unsigned int plt_entry_size;
663
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
668
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset;
671
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte *pic_plt0_entry;
674
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte *pic_plt_entry;
677
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte *eh_frame_plt;
680 unsigned int eh_frame_plt_size;
681 };
682
683 #define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
685
686 /* These are the standard parameters. */
687 static const struct elf_i386_plt_layout elf_i386_plt =
688 {
689 elf_i386_plt0_entry, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry, /* plt_entry */
694 PLT_ENTRY_SIZE, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry, /* pic_plt_entry */
701 elf_i386_eh_frame_plt, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
703 };
704 \f
705
706 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708 #define PLTRESOLVE_RELOCS_SHLIB 0
709 #define PLTRESOLVE_RELOCS 2
710 #define PLT_NON_JUMP_SLOT_RELOCS 2
711
712 /* Architecture-specific backend data for i386. */
713
714 struct elf_i386_backend_data
715 {
716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout *plt;
718
719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte;
721
722 /* True if the target system is VxWorks. */
723 int is_vxworks;
724 };
725
726 #define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
729
730 /* These are the standard parameters. */
731 static const struct elf_i386_backend_data elf_i386_arch_bed =
732 {
733 &elf_i386_plt, /* plt */
734 0, /* plt0_pad_byte */
735 0, /* is_vxworks */
736 };
737
738 #define elf_backend_arch_data &elf_i386_arch_bed
739
740 /* i386 ELF linker hash entry. */
741
742 struct elf_i386_link_hash_entry
743 {
744 struct elf_link_hash_entry elf;
745
746 /* Track dynamic relocs copied for this symbol. */
747 struct elf_dyn_relocs *dyn_relocs;
748
749 #define GOT_UNKNOWN 0
750 #define GOT_NORMAL 1
751 #define GOT_TLS_GD 2
752 #define GOT_TLS_IE 4
753 #define GOT_TLS_IE_POS 5
754 #define GOT_TLS_IE_NEG 6
755 #define GOT_TLS_IE_BOTH 7
756 #define GOT_TLS_GDESC 8
757 #define GOT_TLS_GD_BOTH_P(type) \
758 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
759 #define GOT_TLS_GD_P(type) \
760 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
761 #define GOT_TLS_GDESC_P(type) \
762 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
763 #define GOT_TLS_GD_ANY_P(type) \
764 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
765 unsigned char tls_type;
766
767 /* Symbol is referenced by R_386_GOTOFF relocation. */
768 unsigned int gotoff_ref : 1;
769
770 /* Reference count of C/C++ function pointer relocations in read-write
771 section which can be resolved at run-time. */
772 bfd_signed_vma func_pointer_refcount;
773
774 /* Information about the GOT PLT entry. Filled when there are both
775 GOT and PLT relocations against the same function. */
776 union gotplt_union plt_got;
777
778 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
779 starting at the end of the jump table. */
780 bfd_vma tlsdesc_got;
781 };
782
783 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
784
785 struct elf_i386_obj_tdata
786 {
787 struct elf_obj_tdata root;
788
789 /* tls_type for each local got entry. */
790 char *local_got_tls_type;
791
792 /* GOTPLT entries for TLS descriptors. */
793 bfd_vma *local_tlsdesc_gotent;
794 };
795
796 #define elf_i386_tdata(abfd) \
797 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
798
799 #define elf_i386_local_got_tls_type(abfd) \
800 (elf_i386_tdata (abfd)->local_got_tls_type)
801
802 #define elf_i386_local_tlsdesc_gotent(abfd) \
803 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
804
805 #define is_i386_elf(bfd) \
806 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
807 && elf_tdata (bfd) != NULL \
808 && elf_object_id (bfd) == I386_ELF_DATA)
809
810 static bfd_boolean
811 elf_i386_mkobject (bfd *abfd)
812 {
813 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
814 I386_ELF_DATA);
815 }
816
817 /* i386 ELF linker hash table. */
818
819 struct elf_i386_link_hash_table
820 {
821 struct elf_link_hash_table elf;
822
823 /* Short-cuts to get to dynamic linker sections. */
824 asection *sdynbss;
825 asection *srelbss;
826 asection *plt_eh_frame;
827 asection *plt_got;
828
829 union
830 {
831 bfd_signed_vma refcount;
832 bfd_vma offset;
833 } tls_ldm_got;
834
835 /* The amount of space used by the reserved portion of the sgotplt
836 section, plus whatever space is used by the jump slots. */
837 bfd_vma sgotplt_jump_table_size;
838
839 /* Small local sym cache. */
840 struct sym_cache sym_cache;
841
842 /* _TLS_MODULE_BASE_ symbol. */
843 struct bfd_link_hash_entry *tls_module_base;
844
845 /* Used by local STT_GNU_IFUNC symbols. */
846 htab_t loc_hash_table;
847 void * loc_hash_memory;
848
849 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
850 asection *srelplt2;
851
852 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
853 bfd_vma next_tls_desc_index;
854
855 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
856 bfd_vma next_jump_slot_index;
857
858 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
859 bfd_vma next_irelative_index;
860 };
861
862 /* Get the i386 ELF linker hash table from a link_info structure. */
863
864 #define elf_i386_hash_table(p) \
865 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
866 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
867
868 #define elf_i386_compute_jump_table_size(htab) \
869 ((htab)->elf.srelplt->reloc_count * 4)
870
871 /* Create an entry in an i386 ELF linker hash table. */
872
873 static struct bfd_hash_entry *
874 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
875 struct bfd_hash_table *table,
876 const char *string)
877 {
878 /* Allocate the structure if it has not already been allocated by a
879 subclass. */
880 if (entry == NULL)
881 {
882 entry = (struct bfd_hash_entry *)
883 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
884 if (entry == NULL)
885 return entry;
886 }
887
888 /* Call the allocation method of the superclass. */
889 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
890 if (entry != NULL)
891 {
892 struct elf_i386_link_hash_entry *eh;
893
894 eh = (struct elf_i386_link_hash_entry *) entry;
895 eh->dyn_relocs = NULL;
896 eh->tls_type = GOT_UNKNOWN;
897 eh->gotoff_ref = 0;
898 eh->func_pointer_refcount = 0;
899 eh->plt_got.offset = (bfd_vma) -1;
900 eh->tlsdesc_got = (bfd_vma) -1;
901 }
902
903 return entry;
904 }
905
906 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
907 for local symbol so that we can handle local STT_GNU_IFUNC symbols
908 as global symbol. We reuse indx and dynstr_index for local symbol
909 hash since they aren't used by global symbols in this backend. */
910
911 static hashval_t
912 elf_i386_local_htab_hash (const void *ptr)
913 {
914 struct elf_link_hash_entry *h
915 = (struct elf_link_hash_entry *) ptr;
916 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
917 }
918
919 /* Compare local hash entries. */
920
921 static int
922 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
923 {
924 struct elf_link_hash_entry *h1
925 = (struct elf_link_hash_entry *) ptr1;
926 struct elf_link_hash_entry *h2
927 = (struct elf_link_hash_entry *) ptr2;
928
929 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
930 }
931
932 /* Find and/or create a hash entry for local symbol. */
933
934 static struct elf_link_hash_entry *
935 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
936 bfd *abfd, const Elf_Internal_Rela *rel,
937 bfd_boolean create)
938 {
939 struct elf_i386_link_hash_entry e, *ret;
940 asection *sec = abfd->sections;
941 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
942 ELF32_R_SYM (rel->r_info));
943 void **slot;
944
945 e.elf.indx = sec->id;
946 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
947 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
948 create ? INSERT : NO_INSERT);
949
950 if (!slot)
951 return NULL;
952
953 if (*slot)
954 {
955 ret = (struct elf_i386_link_hash_entry *) *slot;
956 return &ret->elf;
957 }
958
959 ret = (struct elf_i386_link_hash_entry *)
960 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
961 sizeof (struct elf_i386_link_hash_entry));
962 if (ret)
963 {
964 memset (ret, 0, sizeof (*ret));
965 ret->elf.indx = sec->id;
966 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
967 ret->elf.dynindx = -1;
968 ret->func_pointer_refcount = 0;
969 ret->plt_got.offset = (bfd_vma) -1;
970 *slot = ret;
971 }
972 return &ret->elf;
973 }
974
975 /* Destroy an i386 ELF linker hash table. */
976
977 static void
978 elf_i386_link_hash_table_free (bfd *obfd)
979 {
980 struct elf_i386_link_hash_table *htab
981 = (struct elf_i386_link_hash_table *) obfd->link.hash;
982
983 if (htab->loc_hash_table)
984 htab_delete (htab->loc_hash_table);
985 if (htab->loc_hash_memory)
986 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
987 _bfd_elf_link_hash_table_free (obfd);
988 }
989
990 /* Create an i386 ELF linker hash table. */
991
992 static struct bfd_link_hash_table *
993 elf_i386_link_hash_table_create (bfd *abfd)
994 {
995 struct elf_i386_link_hash_table *ret;
996 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
997
998 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
999 if (ret == NULL)
1000 return NULL;
1001
1002 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1003 elf_i386_link_hash_newfunc,
1004 sizeof (struct elf_i386_link_hash_entry),
1005 I386_ELF_DATA))
1006 {
1007 free (ret);
1008 return NULL;
1009 }
1010
1011 ret->loc_hash_table = htab_try_create (1024,
1012 elf_i386_local_htab_hash,
1013 elf_i386_local_htab_eq,
1014 NULL);
1015 ret->loc_hash_memory = objalloc_create ();
1016 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1017 {
1018 elf_i386_link_hash_table_free (abfd);
1019 return NULL;
1020 }
1021 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
1022
1023 return &ret->elf.root;
1024 }
1025
1026 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1027 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1028 hash table. */
1029
1030 static bfd_boolean
1031 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1032 {
1033 struct elf_i386_link_hash_table *htab;
1034
1035 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1036 return FALSE;
1037
1038 htab = elf_i386_hash_table (info);
1039 if (htab == NULL)
1040 return FALSE;
1041
1042 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1043 if (!htab->sdynbss)
1044 abort ();
1045
1046 if (bfd_link_executable (info))
1047 {
1048 /* Always allow copy relocs for building executables. */
1049 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1050 if (s == NULL)
1051 {
1052 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1053 s = bfd_make_section_anyway_with_flags (dynobj,
1054 ".rel.bss",
1055 (bed->dynamic_sec_flags
1056 | SEC_READONLY));
1057 if (s == NULL
1058 || ! bfd_set_section_alignment (dynobj, s,
1059 bed->s->log_file_align))
1060 return FALSE;
1061 }
1062 htab->srelbss = s;
1063 }
1064
1065 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1066 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1067 &htab->srelplt2))
1068 return FALSE;
1069
1070 if (!info->no_ld_generated_unwind_info
1071 && htab->plt_eh_frame == NULL
1072 && htab->elf.splt != NULL)
1073 {
1074 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1075 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1076 | SEC_LINKER_CREATED);
1077 htab->plt_eh_frame
1078 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1079 if (htab->plt_eh_frame == NULL
1080 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1081 return FALSE;
1082 }
1083
1084 return TRUE;
1085 }
1086
1087 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1088
1089 static void
1090 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1091 struct elf_link_hash_entry *dir,
1092 struct elf_link_hash_entry *ind)
1093 {
1094 struct elf_i386_link_hash_entry *edir, *eind;
1095
1096 edir = (struct elf_i386_link_hash_entry *) dir;
1097 eind = (struct elf_i386_link_hash_entry *) ind;
1098
1099 if (eind->dyn_relocs != NULL)
1100 {
1101 if (edir->dyn_relocs != NULL)
1102 {
1103 struct elf_dyn_relocs **pp;
1104 struct elf_dyn_relocs *p;
1105
1106 /* Add reloc counts against the indirect sym to the direct sym
1107 list. Merge any entries against the same section. */
1108 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1109 {
1110 struct elf_dyn_relocs *q;
1111
1112 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1113 if (q->sec == p->sec)
1114 {
1115 q->pc_count += p->pc_count;
1116 q->count += p->count;
1117 *pp = p->next;
1118 break;
1119 }
1120 if (q == NULL)
1121 pp = &p->next;
1122 }
1123 *pp = edir->dyn_relocs;
1124 }
1125
1126 edir->dyn_relocs = eind->dyn_relocs;
1127 eind->dyn_relocs = NULL;
1128 }
1129
1130 if (ind->root.type == bfd_link_hash_indirect
1131 && dir->got.refcount <= 0)
1132 {
1133 edir->tls_type = eind->tls_type;
1134 eind->tls_type = GOT_UNKNOWN;
1135 }
1136
1137 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1138 generate a R_386_COPY reloc. */
1139 edir->gotoff_ref |= eind->gotoff_ref;
1140
1141 if (ELIMINATE_COPY_RELOCS
1142 && ind->root.type != bfd_link_hash_indirect
1143 && dir->dynamic_adjusted)
1144 {
1145 /* If called to transfer flags for a weakdef during processing
1146 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1147 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1148 dir->ref_dynamic |= ind->ref_dynamic;
1149 dir->ref_regular |= ind->ref_regular;
1150 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1151 dir->needs_plt |= ind->needs_plt;
1152 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1153 }
1154 else
1155 {
1156 if (eind->func_pointer_refcount > 0)
1157 {
1158 edir->func_pointer_refcount += eind->func_pointer_refcount;
1159 eind->func_pointer_refcount = 0;
1160 }
1161
1162 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1163 }
1164 }
1165
1166 /* Return TRUE if the TLS access code sequence support transition
1167 from R_TYPE. */
1168
1169 static bfd_boolean
1170 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1171 bfd_byte *contents,
1172 Elf_Internal_Shdr *symtab_hdr,
1173 struct elf_link_hash_entry **sym_hashes,
1174 unsigned int r_type,
1175 const Elf_Internal_Rela *rel,
1176 const Elf_Internal_Rela *relend)
1177 {
1178 unsigned int val, type;
1179 unsigned long r_symndx;
1180 struct elf_link_hash_entry *h;
1181 bfd_vma offset;
1182
1183 /* Get the section contents. */
1184 if (contents == NULL)
1185 {
1186 if (elf_section_data (sec)->this_hdr.contents != NULL)
1187 contents = elf_section_data (sec)->this_hdr.contents;
1188 else
1189 {
1190 /* FIXME: How to better handle error condition? */
1191 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1192 return FALSE;
1193
1194 /* Cache the section contents for elf_link_input_bfd. */
1195 elf_section_data (sec)->this_hdr.contents = contents;
1196 }
1197 }
1198
1199 offset = rel->r_offset;
1200 switch (r_type)
1201 {
1202 case R_386_TLS_GD:
1203 case R_386_TLS_LDM:
1204 if (offset < 2 || (rel + 1) >= relend)
1205 return FALSE;
1206
1207 type = bfd_get_8 (abfd, contents + offset - 2);
1208 if (r_type == R_386_TLS_GD)
1209 {
1210 /* Check transition from GD access model. Only
1211 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1212 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1213 can transit to different access model. */
1214 if ((offset + 10) > sec->size ||
1215 (type != 0x8d && type != 0x04))
1216 return FALSE;
1217
1218 val = bfd_get_8 (abfd, contents + offset - 1);
1219 if (type == 0x04)
1220 {
1221 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1222 if (offset < 3)
1223 return FALSE;
1224
1225 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1226 return FALSE;
1227
1228 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1229 return FALSE;
1230 }
1231 else
1232 {
1233 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1234 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1235 return FALSE;
1236
1237 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1238 return FALSE;
1239 }
1240 }
1241 else
1242 {
1243 /* Check transition from LD access model. Only
1244 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1245 can transit to different access model. */
1246 if (type != 0x8d || (offset + 9) > sec->size)
1247 return FALSE;
1248
1249 val = bfd_get_8 (abfd, contents + offset - 1);
1250 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1251 return FALSE;
1252 }
1253
1254 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1255 return FALSE;
1256
1257 r_symndx = ELF32_R_SYM (rel[1].r_info);
1258 if (r_symndx < symtab_hdr->sh_info)
1259 return FALSE;
1260
1261 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1262 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1263 may be versioned. */
1264 return (h != NULL
1265 && h->root.root.string != NULL
1266 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1267 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1268 && (strncmp (h->root.root.string, "___tls_get_addr",
1269 15) == 0));
1270
1271 case R_386_TLS_IE:
1272 /* Check transition from IE access model:
1273 movl foo@indntpoff(%rip), %eax
1274 movl foo@indntpoff(%rip), %reg
1275 addl foo@indntpoff(%rip), %reg
1276 */
1277
1278 if (offset < 1 || (offset + 4) > sec->size)
1279 return FALSE;
1280
1281 /* Check "movl foo@tpoff(%rip), %eax" first. */
1282 val = bfd_get_8 (abfd, contents + offset - 1);
1283 if (val == 0xa1)
1284 return TRUE;
1285
1286 if (offset < 2)
1287 return FALSE;
1288
1289 /* Check movl|addl foo@tpoff(%rip), %reg. */
1290 type = bfd_get_8 (abfd, contents + offset - 2);
1291 return ((type == 0x8b || type == 0x03)
1292 && (val & 0xc7) == 0x05);
1293
1294 case R_386_TLS_GOTIE:
1295 case R_386_TLS_IE_32:
1296 /* Check transition from {IE_32,GOTIE} access model:
1297 subl foo@{tpoff,gontoff}(%reg1), %reg2
1298 movl foo@{tpoff,gontoff}(%reg1), %reg2
1299 addl foo@{tpoff,gontoff}(%reg1), %reg2
1300 */
1301
1302 if (offset < 2 || (offset + 4) > sec->size)
1303 return FALSE;
1304
1305 val = bfd_get_8 (abfd, contents + offset - 1);
1306 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1307 return FALSE;
1308
1309 type = bfd_get_8 (abfd, contents + offset - 2);
1310 return type == 0x8b || type == 0x2b || type == 0x03;
1311
1312 case R_386_TLS_GOTDESC:
1313 /* Check transition from GDesc access model:
1314 leal x@tlsdesc(%ebx), %eax
1315
1316 Make sure it's a leal adding ebx to a 32-bit offset
1317 into any register, although it's probably almost always
1318 going to be eax. */
1319
1320 if (offset < 2 || (offset + 4) > sec->size)
1321 return FALSE;
1322
1323 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1324 return FALSE;
1325
1326 val = bfd_get_8 (abfd, contents + offset - 1);
1327 return (val & 0xc7) == 0x83;
1328
1329 case R_386_TLS_DESC_CALL:
1330 /* Check transition from GDesc access model:
1331 call *x@tlsdesc(%rax)
1332 */
1333 if (offset + 2 <= sec->size)
1334 {
1335 /* Make sure that it's a call *x@tlsdesc(%rax). */
1336 static const unsigned char call[] = { 0xff, 0x10 };
1337 return memcmp (contents + offset, call, 2) == 0;
1338 }
1339
1340 return FALSE;
1341
1342 default:
1343 abort ();
1344 }
1345 }
1346
1347 /* Return TRUE if the TLS access transition is OK or no transition
1348 will be performed. Update R_TYPE if there is a transition. */
1349
1350 static bfd_boolean
1351 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1352 asection *sec, bfd_byte *contents,
1353 Elf_Internal_Shdr *symtab_hdr,
1354 struct elf_link_hash_entry **sym_hashes,
1355 unsigned int *r_type, int tls_type,
1356 const Elf_Internal_Rela *rel,
1357 const Elf_Internal_Rela *relend,
1358 struct elf_link_hash_entry *h,
1359 unsigned long r_symndx)
1360 {
1361 unsigned int from_type = *r_type;
1362 unsigned int to_type = from_type;
1363 bfd_boolean check = TRUE;
1364
1365 /* Skip TLS transition for functions. */
1366 if (h != NULL
1367 && (h->type == STT_FUNC
1368 || h->type == STT_GNU_IFUNC))
1369 return TRUE;
1370
1371 switch (from_type)
1372 {
1373 case R_386_TLS_GD:
1374 case R_386_TLS_GOTDESC:
1375 case R_386_TLS_DESC_CALL:
1376 case R_386_TLS_IE_32:
1377 case R_386_TLS_IE:
1378 case R_386_TLS_GOTIE:
1379 if (bfd_link_executable (info))
1380 {
1381 if (h == NULL)
1382 to_type = R_386_TLS_LE_32;
1383 else if (from_type != R_386_TLS_IE
1384 && from_type != R_386_TLS_GOTIE)
1385 to_type = R_386_TLS_IE_32;
1386 }
1387
1388 /* When we are called from elf_i386_relocate_section, CONTENTS
1389 isn't NULL and there may be additional transitions based on
1390 TLS_TYPE. */
1391 if (contents != NULL)
1392 {
1393 unsigned int new_to_type = to_type;
1394
1395 if (bfd_link_executable (info)
1396 && h != NULL
1397 && h->dynindx == -1
1398 && (tls_type & GOT_TLS_IE))
1399 new_to_type = R_386_TLS_LE_32;
1400
1401 if (to_type == R_386_TLS_GD
1402 || to_type == R_386_TLS_GOTDESC
1403 || to_type == R_386_TLS_DESC_CALL)
1404 {
1405 if (tls_type == GOT_TLS_IE_POS)
1406 new_to_type = R_386_TLS_GOTIE;
1407 else if (tls_type & GOT_TLS_IE)
1408 new_to_type = R_386_TLS_IE_32;
1409 }
1410
1411 /* We checked the transition before when we were called from
1412 elf_i386_check_relocs. We only want to check the new
1413 transition which hasn't been checked before. */
1414 check = new_to_type != to_type && from_type == to_type;
1415 to_type = new_to_type;
1416 }
1417
1418 break;
1419
1420 case R_386_TLS_LDM:
1421 if (bfd_link_executable (info))
1422 to_type = R_386_TLS_LE_32;
1423 break;
1424
1425 default:
1426 return TRUE;
1427 }
1428
1429 /* Return TRUE if there is no transition. */
1430 if (from_type == to_type)
1431 return TRUE;
1432
1433 /* Check if the transition can be performed. */
1434 if (check
1435 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1436 symtab_hdr, sym_hashes,
1437 from_type, rel, relend))
1438 {
1439 reloc_howto_type *from, *to;
1440 const char *name;
1441
1442 from = elf_i386_rtype_to_howto (abfd, from_type);
1443 to = elf_i386_rtype_to_howto (abfd, to_type);
1444
1445 if (h)
1446 name = h->root.root.string;
1447 else
1448 {
1449 struct elf_i386_link_hash_table *htab;
1450
1451 htab = elf_i386_hash_table (info);
1452 if (htab == NULL)
1453 name = "*unknown*";
1454 else
1455 {
1456 Elf_Internal_Sym *isym;
1457
1458 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1459 abfd, r_symndx);
1460 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1461 }
1462 }
1463
1464 (*_bfd_error_handler)
1465 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1466 "in section `%A' failed"),
1467 abfd, sec, from->name, to->name, name,
1468 (unsigned long) rel->r_offset);
1469 bfd_set_error (bfd_error_bad_value);
1470 return FALSE;
1471 }
1472
1473 *r_type = to_type;
1474 return TRUE;
1475 }
1476
1477 /* Rename some of the generic section flags to better document how they
1478 are used here. */
1479 #define need_convert_load sec_flg0
1480
1481 /* Look through the relocs for a section during the first phase, and
1482 calculate needed space in the global offset table, procedure linkage
1483 table, and dynamic reloc sections. */
1484
1485 static bfd_boolean
1486 elf_i386_check_relocs (bfd *abfd,
1487 struct bfd_link_info *info,
1488 asection *sec,
1489 const Elf_Internal_Rela *relocs)
1490 {
1491 struct elf_i386_link_hash_table *htab;
1492 Elf_Internal_Shdr *symtab_hdr;
1493 struct elf_link_hash_entry **sym_hashes;
1494 const Elf_Internal_Rela *rel;
1495 const Elf_Internal_Rela *rel_end;
1496 asection *sreloc;
1497 bfd_boolean use_plt_got;
1498
1499 if (bfd_link_relocatable (info))
1500 return TRUE;
1501
1502 BFD_ASSERT (is_i386_elf (abfd));
1503
1504 htab = elf_i386_hash_table (info);
1505 if (htab == NULL)
1506 return FALSE;
1507
1508 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1509 && (get_elf_i386_backend_data (abfd)
1510 == &elf_i386_arch_bed));
1511
1512 symtab_hdr = &elf_symtab_hdr (abfd);
1513 sym_hashes = elf_sym_hashes (abfd);
1514
1515 sreloc = NULL;
1516
1517 rel_end = relocs + sec->reloc_count;
1518 for (rel = relocs; rel < rel_end; rel++)
1519 {
1520 unsigned int r_type;
1521 unsigned long r_symndx;
1522 struct elf_link_hash_entry *h;
1523 struct elf_i386_link_hash_entry *eh;
1524 Elf_Internal_Sym *isym;
1525 const char *name;
1526 bfd_boolean size_reloc;
1527
1528 r_symndx = ELF32_R_SYM (rel->r_info);
1529 r_type = ELF32_R_TYPE (rel->r_info);
1530
1531 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1532 {
1533 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1534 abfd,
1535 r_symndx);
1536 return FALSE;
1537 }
1538
1539 if (r_symndx < symtab_hdr->sh_info)
1540 {
1541 /* A local symbol. */
1542 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1543 abfd, r_symndx);
1544 if (isym == NULL)
1545 return FALSE;
1546
1547 /* Check relocation against local STT_GNU_IFUNC symbol. */
1548 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1549 {
1550 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1551 if (h == NULL)
1552 return FALSE;
1553
1554 /* Fake a STT_GNU_IFUNC symbol. */
1555 h->type = STT_GNU_IFUNC;
1556 h->def_regular = 1;
1557 h->ref_regular = 1;
1558 h->forced_local = 1;
1559 h->root.type = bfd_link_hash_defined;
1560 }
1561 else
1562 h = NULL;
1563 }
1564 else
1565 {
1566 isym = NULL;
1567 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1568 while (h->root.type == bfd_link_hash_indirect
1569 || h->root.type == bfd_link_hash_warning)
1570 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1571 }
1572
1573 eh = (struct elf_i386_link_hash_entry *) h;
1574 if (h != NULL)
1575 {
1576 /* Create the ifunc sections for static executables. If we
1577 never see an indirect function symbol nor we are building
1578 a static executable, those sections will be empty and
1579 won't appear in output. */
1580 switch (r_type)
1581 {
1582 default:
1583 break;
1584
1585 case R_386_GOTOFF:
1586 eh->gotoff_ref = 1;
1587 case R_386_32:
1588 case R_386_PC32:
1589 case R_386_PLT32:
1590 case R_386_GOT32:
1591 case R_386_GOT32X:
1592 if (htab->elf.dynobj == NULL)
1593 htab->elf.dynobj = abfd;
1594 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1595 return FALSE;
1596 break;
1597 }
1598
1599 /* It is referenced by a non-shared object. */
1600 h->ref_regular = 1;
1601 h->root.non_ir_ref = 1;
1602
1603 if (h->type == STT_GNU_IFUNC)
1604 elf_tdata (info->output_bfd)->has_gnu_symbols
1605 |= elf_gnu_symbol_ifunc;
1606 }
1607
1608 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1609 symtab_hdr, sym_hashes,
1610 &r_type, GOT_UNKNOWN,
1611 rel, rel_end, h, r_symndx))
1612 return FALSE;
1613
1614 switch (r_type)
1615 {
1616 case R_386_TLS_LDM:
1617 htab->tls_ldm_got.refcount += 1;
1618 goto create_got;
1619
1620 case R_386_PLT32:
1621 /* This symbol requires a procedure linkage table entry. We
1622 actually build the entry in adjust_dynamic_symbol,
1623 because this might be a case of linking PIC code which is
1624 never referenced by a dynamic object, in which case we
1625 don't need to generate a procedure linkage table entry
1626 after all. */
1627
1628 /* If this is a local symbol, we resolve it directly without
1629 creating a procedure linkage table entry. */
1630 if (h == NULL)
1631 continue;
1632
1633 h->needs_plt = 1;
1634 h->plt.refcount += 1;
1635 break;
1636
1637 case R_386_SIZE32:
1638 size_reloc = TRUE;
1639 goto do_size;
1640
1641 case R_386_TLS_IE_32:
1642 case R_386_TLS_IE:
1643 case R_386_TLS_GOTIE:
1644 if (!bfd_link_executable (info))
1645 info->flags |= DF_STATIC_TLS;
1646 /* Fall through */
1647
1648 case R_386_GOT32:
1649 case R_386_GOT32X:
1650 case R_386_TLS_GD:
1651 case R_386_TLS_GOTDESC:
1652 case R_386_TLS_DESC_CALL:
1653 /* This symbol requires a global offset table entry. */
1654 {
1655 int tls_type, old_tls_type;
1656
1657 switch (r_type)
1658 {
1659 default:
1660 case R_386_GOT32:
1661 case R_386_GOT32X:
1662 tls_type = GOT_NORMAL;
1663 break;
1664 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1665 case R_386_TLS_GOTDESC:
1666 case R_386_TLS_DESC_CALL:
1667 tls_type = GOT_TLS_GDESC; break;
1668 case R_386_TLS_IE_32:
1669 if (ELF32_R_TYPE (rel->r_info) == r_type)
1670 tls_type = GOT_TLS_IE_NEG;
1671 else
1672 /* If this is a GD->IE transition, we may use either of
1673 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1674 tls_type = GOT_TLS_IE;
1675 break;
1676 case R_386_TLS_IE:
1677 case R_386_TLS_GOTIE:
1678 tls_type = GOT_TLS_IE_POS; break;
1679 }
1680
1681 if (h != NULL)
1682 {
1683 h->got.refcount += 1;
1684 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1685 }
1686 else
1687 {
1688 bfd_signed_vma *local_got_refcounts;
1689
1690 /* This is a global offset table entry for a local symbol. */
1691 local_got_refcounts = elf_local_got_refcounts (abfd);
1692 if (local_got_refcounts == NULL)
1693 {
1694 bfd_size_type size;
1695
1696 size = symtab_hdr->sh_info;
1697 size *= (sizeof (bfd_signed_vma)
1698 + sizeof (bfd_vma) + sizeof(char));
1699 local_got_refcounts = (bfd_signed_vma *)
1700 bfd_zalloc (abfd, size);
1701 if (local_got_refcounts == NULL)
1702 return FALSE;
1703 elf_local_got_refcounts (abfd) = local_got_refcounts;
1704 elf_i386_local_tlsdesc_gotent (abfd)
1705 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1706 elf_i386_local_got_tls_type (abfd)
1707 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1708 }
1709 local_got_refcounts[r_symndx] += 1;
1710 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1711 }
1712
1713 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1714 tls_type |= old_tls_type;
1715 /* If a TLS symbol is accessed using IE at least once,
1716 there is no point to use dynamic model for it. */
1717 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1718 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1719 || (tls_type & GOT_TLS_IE) == 0))
1720 {
1721 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1722 tls_type = old_tls_type;
1723 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1724 && GOT_TLS_GD_ANY_P (tls_type))
1725 tls_type |= old_tls_type;
1726 else
1727 {
1728 if (h)
1729 name = h->root.root.string;
1730 else
1731 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1732 NULL);
1733 (*_bfd_error_handler)
1734 (_("%B: `%s' accessed both as normal and "
1735 "thread local symbol"),
1736 abfd, name);
1737 bfd_set_error (bfd_error_bad_value);
1738 return FALSE;
1739 }
1740 }
1741
1742 if (old_tls_type != tls_type)
1743 {
1744 if (h != NULL)
1745 elf_i386_hash_entry (h)->tls_type = tls_type;
1746 else
1747 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1748 }
1749 }
1750 /* Fall through */
1751
1752 case R_386_GOTOFF:
1753 case R_386_GOTPC:
1754 create_got:
1755 if (htab->elf.sgot == NULL)
1756 {
1757 if (htab->elf.dynobj == NULL)
1758 htab->elf.dynobj = abfd;
1759 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1760 return FALSE;
1761 }
1762 if (r_type != R_386_TLS_IE)
1763 break;
1764 /* Fall through */
1765
1766 case R_386_TLS_LE_32:
1767 case R_386_TLS_LE:
1768 if (bfd_link_executable (info))
1769 break;
1770 info->flags |= DF_STATIC_TLS;
1771 /* Fall through */
1772
1773 case R_386_32:
1774 case R_386_PC32:
1775 if (h != NULL && bfd_link_executable (info))
1776 {
1777 /* If this reloc is in a read-only section, we might
1778 need a copy reloc. We can't check reliably at this
1779 stage whether the section is read-only, as input
1780 sections have not yet been mapped to output sections.
1781 Tentatively set the flag for now, and correct in
1782 adjust_dynamic_symbol. */
1783 h->non_got_ref = 1;
1784
1785 /* We may need a .plt entry if the function this reloc
1786 refers to is in a shared lib. */
1787 h->plt.refcount += 1;
1788 if (r_type == R_386_PC32)
1789 {
1790 /* Since something like ".long foo - ." may be used
1791 as pointer, make sure that PLT is used if foo is
1792 a function defined in a shared library. */
1793 if ((sec->flags & SEC_CODE) == 0)
1794 h->pointer_equality_needed = 1;
1795 }
1796 else
1797 {
1798 h->pointer_equality_needed = 1;
1799 /* R_386_32 can be resolved at run-time. */
1800 if (r_type == R_386_32
1801 && (sec->flags & SEC_READONLY) == 0)
1802 eh->func_pointer_refcount += 1;
1803 }
1804 }
1805
1806 size_reloc = FALSE;
1807 do_size:
1808 /* If we are creating a shared library, and this is a reloc
1809 against a global symbol, or a non PC relative reloc
1810 against a local symbol, then we need to copy the reloc
1811 into the shared library. However, if we are linking with
1812 -Bsymbolic, we do not need to copy a reloc against a
1813 global symbol which is defined in an object we are
1814 including in the link (i.e., DEF_REGULAR is set). At
1815 this point we have not seen all the input files, so it is
1816 possible that DEF_REGULAR is not set now but will be set
1817 later (it is never cleared). In case of a weak definition,
1818 DEF_REGULAR may be cleared later by a strong definition in
1819 a shared library. We account for that possibility below by
1820 storing information in the relocs_copied field of the hash
1821 table entry. A similar situation occurs when creating
1822 shared libraries and symbol visibility changes render the
1823 symbol local.
1824
1825 If on the other hand, we are creating an executable, we
1826 may need to keep relocations for symbols satisfied by a
1827 dynamic library if we manage to avoid copy relocs for the
1828 symbol. */
1829 if ((bfd_link_pic (info)
1830 && (sec->flags & SEC_ALLOC) != 0
1831 && (r_type != R_386_PC32
1832 || (h != NULL
1833 && (! SYMBOLIC_BIND (info, h)
1834 || h->root.type == bfd_link_hash_defweak
1835 || !h->def_regular))))
1836 || (ELIMINATE_COPY_RELOCS
1837 && !bfd_link_pic (info)
1838 && (sec->flags & SEC_ALLOC) != 0
1839 && h != NULL
1840 && (h->root.type == bfd_link_hash_defweak
1841 || !h->def_regular)))
1842 {
1843 struct elf_dyn_relocs *p;
1844 struct elf_dyn_relocs **head;
1845
1846 /* We must copy these reloc types into the output file.
1847 Create a reloc section in dynobj and make room for
1848 this reloc. */
1849 if (sreloc == NULL)
1850 {
1851 if (htab->elf.dynobj == NULL)
1852 htab->elf.dynobj = abfd;
1853
1854 sreloc = _bfd_elf_make_dynamic_reloc_section
1855 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1856
1857 if (sreloc == NULL)
1858 return FALSE;
1859 }
1860
1861 /* If this is a global symbol, we count the number of
1862 relocations we need for this symbol. */
1863 if (h != NULL)
1864 {
1865 head = &eh->dyn_relocs;
1866 }
1867 else
1868 {
1869 /* Track dynamic relocs needed for local syms too.
1870 We really need local syms available to do this
1871 easily. Oh well. */
1872 void **vpp;
1873 asection *s;
1874
1875 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1876 abfd, r_symndx);
1877 if (isym == NULL)
1878 return FALSE;
1879
1880 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1881 if (s == NULL)
1882 s = sec;
1883
1884 vpp = &elf_section_data (s)->local_dynrel;
1885 head = (struct elf_dyn_relocs **)vpp;
1886 }
1887
1888 p = *head;
1889 if (p == NULL || p->sec != sec)
1890 {
1891 bfd_size_type amt = sizeof *p;
1892 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1893 amt);
1894 if (p == NULL)
1895 return FALSE;
1896 p->next = *head;
1897 *head = p;
1898 p->sec = sec;
1899 p->count = 0;
1900 p->pc_count = 0;
1901 }
1902
1903 p->count += 1;
1904 /* Count size relocation as PC-relative relocation. */
1905 if (r_type == R_386_PC32 || size_reloc)
1906 p->pc_count += 1;
1907 }
1908 break;
1909
1910 /* This relocation describes the C++ object vtable hierarchy.
1911 Reconstruct it for later use during GC. */
1912 case R_386_GNU_VTINHERIT:
1913 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1914 return FALSE;
1915 break;
1916
1917 /* This relocation describes which C++ vtable entries are actually
1918 used. Record for later use during GC. */
1919 case R_386_GNU_VTENTRY:
1920 BFD_ASSERT (h != NULL);
1921 if (h != NULL
1922 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1923 return FALSE;
1924 break;
1925
1926 default:
1927 break;
1928 }
1929
1930 if (use_plt_got
1931 && h != NULL
1932 && h->plt.refcount > 0
1933 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
1934 || h->got.refcount > 0)
1935 && htab->plt_got == NULL)
1936 {
1937 /* Create the GOT procedure linkage table. */
1938 unsigned int plt_got_align;
1939 const struct elf_backend_data *bed;
1940
1941 bed = get_elf_backend_data (info->output_bfd);
1942 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
1943 && (sizeof (elf_i386_got_plt_entry)
1944 == sizeof (elf_i386_pic_got_plt_entry)));
1945 plt_got_align = 3;
1946
1947 if (htab->elf.dynobj == NULL)
1948 htab->elf.dynobj = abfd;
1949 htab->plt_got
1950 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
1951 ".plt.got",
1952 (bed->dynamic_sec_flags
1953 | SEC_ALLOC
1954 | SEC_CODE
1955 | SEC_LOAD
1956 | SEC_READONLY));
1957 if (htab->plt_got == NULL
1958 || !bfd_set_section_alignment (htab->elf.dynobj,
1959 htab->plt_got,
1960 plt_got_align))
1961 return FALSE;
1962 }
1963
1964 if ((r_type == R_386_GOT32 || r_type == R_386_GOT32X)
1965 && (h == NULL || h->type != STT_GNU_IFUNC))
1966 sec->need_convert_load = 1;
1967 }
1968
1969 return TRUE;
1970 }
1971
1972 /* Return the section that should be marked against GC for a given
1973 relocation. */
1974
1975 static asection *
1976 elf_i386_gc_mark_hook (asection *sec,
1977 struct bfd_link_info *info,
1978 Elf_Internal_Rela *rel,
1979 struct elf_link_hash_entry *h,
1980 Elf_Internal_Sym *sym)
1981 {
1982 if (h != NULL)
1983 switch (ELF32_R_TYPE (rel->r_info))
1984 {
1985 case R_386_GNU_VTINHERIT:
1986 case R_386_GNU_VTENTRY:
1987 return NULL;
1988 }
1989
1990 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1991 }
1992
1993 /* Update the got entry reference counts for the section being removed. */
1994
1995 static bfd_boolean
1996 elf_i386_gc_sweep_hook (bfd *abfd,
1997 struct bfd_link_info *info,
1998 asection *sec,
1999 const Elf_Internal_Rela *relocs)
2000 {
2001 struct elf_i386_link_hash_table *htab;
2002 Elf_Internal_Shdr *symtab_hdr;
2003 struct elf_link_hash_entry **sym_hashes;
2004 bfd_signed_vma *local_got_refcounts;
2005 const Elf_Internal_Rela *rel, *relend;
2006
2007 if (bfd_link_relocatable (info))
2008 return TRUE;
2009
2010 htab = elf_i386_hash_table (info);
2011 if (htab == NULL)
2012 return FALSE;
2013
2014 elf_section_data (sec)->local_dynrel = NULL;
2015
2016 symtab_hdr = &elf_symtab_hdr (abfd);
2017 sym_hashes = elf_sym_hashes (abfd);
2018 local_got_refcounts = elf_local_got_refcounts (abfd);
2019
2020 relend = relocs + sec->reloc_count;
2021 for (rel = relocs; rel < relend; rel++)
2022 {
2023 unsigned long r_symndx;
2024 unsigned int r_type;
2025 struct elf_link_hash_entry *h = NULL;
2026
2027 r_symndx = ELF32_R_SYM (rel->r_info);
2028 if (r_symndx >= symtab_hdr->sh_info)
2029 {
2030 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2031 while (h->root.type == bfd_link_hash_indirect
2032 || h->root.type == bfd_link_hash_warning)
2033 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2034 }
2035 else
2036 {
2037 /* A local symbol. */
2038 Elf_Internal_Sym *isym;
2039
2040 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2041 abfd, r_symndx);
2042
2043 /* Check relocation against local STT_GNU_IFUNC symbol. */
2044 if (isym != NULL
2045 && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2046 {
2047 h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
2048 if (h == NULL)
2049 abort ();
2050 }
2051 }
2052
2053 if (h)
2054 {
2055 struct elf_i386_link_hash_entry *eh;
2056 struct elf_dyn_relocs **pp;
2057 struct elf_dyn_relocs *p;
2058
2059 eh = (struct elf_i386_link_hash_entry *) h;
2060 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2061 if (p->sec == sec)
2062 {
2063 /* Everything must go for SEC. */
2064 *pp = p->next;
2065 break;
2066 }
2067 }
2068
2069 r_type = ELF32_R_TYPE (rel->r_info);
2070 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
2071 symtab_hdr, sym_hashes,
2072 &r_type, GOT_UNKNOWN,
2073 rel, relend, h, r_symndx))
2074 return FALSE;
2075
2076 switch (r_type)
2077 {
2078 case R_386_TLS_LDM:
2079 if (htab->tls_ldm_got.refcount > 0)
2080 htab->tls_ldm_got.refcount -= 1;
2081 break;
2082
2083 case R_386_TLS_GD:
2084 case R_386_TLS_GOTDESC:
2085 case R_386_TLS_DESC_CALL:
2086 case R_386_TLS_IE_32:
2087 case R_386_TLS_IE:
2088 case R_386_TLS_GOTIE:
2089 case R_386_GOT32:
2090 case R_386_GOT32X:
2091 if (h != NULL)
2092 {
2093 if (h->got.refcount > 0)
2094 h->got.refcount -= 1;
2095 if (h->type == STT_GNU_IFUNC)
2096 {
2097 if (h->plt.refcount > 0)
2098 h->plt.refcount -= 1;
2099 }
2100 }
2101 else if (local_got_refcounts != NULL)
2102 {
2103 if (local_got_refcounts[r_symndx] > 0)
2104 local_got_refcounts[r_symndx] -= 1;
2105 }
2106 break;
2107
2108 case R_386_32:
2109 case R_386_PC32:
2110 case R_386_SIZE32:
2111 if (bfd_link_pic (info)
2112 && (h == NULL || h->type != STT_GNU_IFUNC))
2113 break;
2114 /* Fall through */
2115
2116 case R_386_PLT32:
2117 if (h != NULL)
2118 {
2119 if (h->plt.refcount > 0)
2120 h->plt.refcount -= 1;
2121 if (r_type == R_386_32
2122 && (sec->flags & SEC_READONLY) == 0)
2123 {
2124 struct elf_i386_link_hash_entry *eh
2125 = (struct elf_i386_link_hash_entry *) h;
2126 if (eh->func_pointer_refcount > 0)
2127 eh->func_pointer_refcount -= 1;
2128 }
2129 }
2130 break;
2131
2132 case R_386_GOTOFF:
2133 if (h != NULL && h->type == STT_GNU_IFUNC)
2134 {
2135 if (h->got.refcount > 0)
2136 h->got.refcount -= 1;
2137 if (h->plt.refcount > 0)
2138 h->plt.refcount -= 1;
2139 }
2140 break;
2141
2142 default:
2143 break;
2144 }
2145 }
2146
2147 return TRUE;
2148 }
2149
2150 /* Adjust a symbol defined by a dynamic object and referenced by a
2151 regular object. The current definition is in some section of the
2152 dynamic object, but we're not including those sections. We have to
2153 change the definition to something the rest of the link can
2154 understand. */
2155
2156 static bfd_boolean
2157 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2158 struct elf_link_hash_entry *h)
2159 {
2160 struct elf_i386_link_hash_table *htab;
2161 asection *s;
2162 struct elf_i386_link_hash_entry *eh;
2163 struct elf_dyn_relocs *p;
2164
2165 /* STT_GNU_IFUNC symbol must go through PLT. */
2166 if (h->type == STT_GNU_IFUNC)
2167 {
2168 /* All local STT_GNU_IFUNC references must be treate as local
2169 calls via local PLT. */
2170 if (h->ref_regular
2171 && SYMBOL_CALLS_LOCAL (info, h))
2172 {
2173 bfd_size_type pc_count = 0, count = 0;
2174 struct elf_dyn_relocs **pp;
2175
2176 eh = (struct elf_i386_link_hash_entry *) h;
2177 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2178 {
2179 pc_count += p->pc_count;
2180 p->count -= p->pc_count;
2181 p->pc_count = 0;
2182 count += p->count;
2183 if (p->count == 0)
2184 *pp = p->next;
2185 else
2186 pp = &p->next;
2187 }
2188
2189 if (pc_count || count)
2190 {
2191 h->needs_plt = 1;
2192 h->non_got_ref = 1;
2193 if (h->plt.refcount <= 0)
2194 h->plt.refcount = 1;
2195 else
2196 h->plt.refcount += 1;
2197 }
2198 }
2199
2200 if (h->plt.refcount <= 0)
2201 {
2202 h->plt.offset = (bfd_vma) -1;
2203 h->needs_plt = 0;
2204 }
2205 return TRUE;
2206 }
2207
2208 /* If this is a function, put it in the procedure linkage table. We
2209 will fill in the contents of the procedure linkage table later,
2210 when we know the address of the .got section. */
2211 if (h->type == STT_FUNC
2212 || h->needs_plt)
2213 {
2214 if (h->plt.refcount <= 0
2215 || SYMBOL_CALLS_LOCAL (info, h)
2216 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2217 && h->root.type == bfd_link_hash_undefweak))
2218 {
2219 /* This case can occur if we saw a PLT32 reloc in an input
2220 file, but the symbol was never referred to by a dynamic
2221 object, or if all references were garbage collected. In
2222 such a case, we don't actually need to build a procedure
2223 linkage table, and we can just do a PC32 reloc instead. */
2224 h->plt.offset = (bfd_vma) -1;
2225 h->needs_plt = 0;
2226 }
2227
2228 return TRUE;
2229 }
2230 else
2231 /* It's possible that we incorrectly decided a .plt reloc was
2232 needed for an R_386_PC32 reloc to a non-function sym in
2233 check_relocs. We can't decide accurately between function and
2234 non-function syms in check-relocs; Objects loaded later in
2235 the link may change h->type. So fix it now. */
2236 h->plt.offset = (bfd_vma) -1;
2237
2238 /* If this is a weak symbol, and there is a real definition, the
2239 processor independent code will have arranged for us to see the
2240 real definition first, and we can just use the same value. */
2241 if (h->u.weakdef != NULL)
2242 {
2243 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2244 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2245 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2246 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2247 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2248 h->non_got_ref = h->u.weakdef->non_got_ref;
2249 return TRUE;
2250 }
2251
2252 /* This is a reference to a symbol defined by a dynamic object which
2253 is not a function. */
2254
2255 /* If we are creating a shared library, we must presume that the
2256 only references to the symbol are via the global offset table.
2257 For such cases we need not do anything here; the relocations will
2258 be handled correctly by relocate_section. */
2259 if (!bfd_link_executable (info))
2260 return TRUE;
2261
2262 /* If there are no references to this symbol that do not use the
2263 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2264 reloc. */
2265 eh = (struct elf_i386_link_hash_entry *) h;
2266 if (!h->non_got_ref && !eh->gotoff_ref)
2267 return TRUE;
2268
2269 /* If -z nocopyreloc was given, we won't generate them either. */
2270 if (info->nocopyreloc)
2271 {
2272 h->non_got_ref = 0;
2273 return TRUE;
2274 }
2275
2276 htab = elf_i386_hash_table (info);
2277 if (htab == NULL)
2278 return FALSE;
2279
2280 /* If there aren't any dynamic relocs in read-only sections nor
2281 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2282 avoid the copy reloc. This doesn't work on VxWorks, where we can
2283 not have dynamic relocations (other than copy and jump slot
2284 relocations) in an executable. */
2285 if (ELIMINATE_COPY_RELOCS
2286 && !eh->gotoff_ref
2287 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2288 {
2289 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2290 {
2291 s = p->sec->output_section;
2292 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2293 break;
2294 }
2295
2296 if (p == NULL)
2297 {
2298 h->non_got_ref = 0;
2299 return TRUE;
2300 }
2301 }
2302
2303 /* We must allocate the symbol in our .dynbss section, which will
2304 become part of the .bss section of the executable. There will be
2305 an entry for this symbol in the .dynsym section. The dynamic
2306 object will contain position independent code, so all references
2307 from the dynamic object to this symbol will go through the global
2308 offset table. The dynamic linker will use the .dynsym entry to
2309 determine the address it must put in the global offset table, so
2310 both the dynamic object and the regular object will refer to the
2311 same memory location for the variable. */
2312
2313 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2314 copy the initial value out of the dynamic object and into the
2315 runtime process image. */
2316 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2317 {
2318 htab->srelbss->size += sizeof (Elf32_External_Rel);
2319 h->needs_copy = 1;
2320 }
2321
2322 s = htab->sdynbss;
2323
2324 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2325 }
2326
2327 /* Allocate space in .plt, .got and associated reloc sections for
2328 dynamic relocs. */
2329
2330 static bfd_boolean
2331 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2332 {
2333 struct bfd_link_info *info;
2334 struct elf_i386_link_hash_table *htab;
2335 struct elf_i386_link_hash_entry *eh;
2336 struct elf_dyn_relocs *p;
2337 unsigned plt_entry_size;
2338
2339 if (h->root.type == bfd_link_hash_indirect)
2340 return TRUE;
2341
2342 eh = (struct elf_i386_link_hash_entry *) h;
2343
2344 info = (struct bfd_link_info *) inf;
2345 htab = elf_i386_hash_table (info);
2346 if (htab == NULL)
2347 return FALSE;
2348
2349 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2350
2351 /* Clear the reference count of function pointer relocations if
2352 symbol isn't a normal function. */
2353 if (h->type != STT_FUNC)
2354 eh->func_pointer_refcount = 0;
2355
2356 /* We can't use the GOT PLT if pointer equality is needed since
2357 finish_dynamic_symbol won't clear symbol value and the dynamic
2358 linker won't update the GOT slot. We will get into an infinite
2359 loop at run-time. */
2360 if (htab->plt_got != NULL
2361 && h->type != STT_GNU_IFUNC
2362 && !h->pointer_equality_needed
2363 && h->plt.refcount > 0
2364 && h->got.refcount > 0)
2365 {
2366 /* Don't use the regular PLT if there are both GOT and GOTPLT
2367 reloctions. */
2368 h->plt.offset = (bfd_vma) -1;
2369
2370 /* Use the GOT PLT. */
2371 eh->plt_got.refcount = 1;
2372 }
2373
2374 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2375 here if it is defined and referenced in a non-shared object. */
2376 if (h->type == STT_GNU_IFUNC
2377 && h->def_regular)
2378 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2379 plt_entry_size,
2380 plt_entry_size, 4);
2381 /* Don't create the PLT entry if there are only function pointer
2382 relocations which can be resolved at run-time. */
2383 else if (htab->elf.dynamic_sections_created
2384 && (h->plt.refcount > eh->func_pointer_refcount
2385 || eh->plt_got.refcount > 0))
2386 {
2387 bfd_boolean use_plt_got;
2388
2389 /* Clear the reference count of function pointer relocations
2390 if PLT is used. */
2391 eh->func_pointer_refcount = 0;
2392
2393 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2394 {
2395 /* Don't use the regular PLT for DF_BIND_NOW. */
2396 h->plt.offset = (bfd_vma) -1;
2397
2398 /* Use the GOT PLT. */
2399 h->got.refcount = 1;
2400 eh->plt_got.refcount = 1;
2401 }
2402
2403 use_plt_got = eh->plt_got.refcount > 0;
2404
2405 /* Make sure this symbol is output as a dynamic symbol.
2406 Undefined weak syms won't yet be marked as dynamic. */
2407 if (h->dynindx == -1
2408 && !h->forced_local)
2409 {
2410 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2411 return FALSE;
2412 }
2413
2414 if (bfd_link_pic (info)
2415 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2416 {
2417 asection *s = htab->elf.splt;
2418 asection *got_s = htab->plt_got;
2419
2420 /* If this is the first .plt entry, make room for the special
2421 first entry. The .plt section is used by prelink to undo
2422 prelinking for dynamic relocations. */
2423 if (s->size == 0)
2424 s->size = plt_entry_size;
2425
2426 if (use_plt_got)
2427 eh->plt_got.offset = got_s->size;
2428 else
2429 h->plt.offset = s->size;
2430
2431 /* If this symbol is not defined in a regular file, and we are
2432 not generating a shared library, then set the symbol to this
2433 location in the .plt. This is required to make function
2434 pointers compare as equal between the normal executable and
2435 the shared library. */
2436 if (! bfd_link_pic (info)
2437 && !h->def_regular)
2438 {
2439 if (use_plt_got)
2440 {
2441 /* We need to make a call to the entry of the GOT PLT
2442 instead of regular PLT entry. */
2443 h->root.u.def.section = got_s;
2444 h->root.u.def.value = eh->plt_got.offset;
2445 }
2446 else
2447 {
2448 h->root.u.def.section = s;
2449 h->root.u.def.value = h->plt.offset;
2450 }
2451 }
2452
2453 /* Make room for this entry. */
2454 if (use_plt_got)
2455 got_s->size += sizeof (elf_i386_got_plt_entry);
2456 else
2457 {
2458 s->size += plt_entry_size;
2459
2460 /* We also need to make an entry in the .got.plt section,
2461 which will be placed in the .got section by the linker
2462 script. */
2463 htab->elf.sgotplt->size += 4;
2464
2465 /* We also need to make an entry in the .rel.plt section. */
2466 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2467 htab->elf.srelplt->reloc_count++;
2468 }
2469
2470 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2471 && !bfd_link_pic (info))
2472 {
2473 /* VxWorks has a second set of relocations for each PLT entry
2474 in executables. They go in a separate relocation section,
2475 which is processed by the kernel loader. */
2476
2477 /* There are two relocations for the initial PLT entry: an
2478 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2479 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2480
2481 if (h->plt.offset == plt_entry_size)
2482 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2483
2484 /* There are two extra relocations for each subsequent PLT entry:
2485 an R_386_32 relocation for the GOT entry, and an R_386_32
2486 relocation for the PLT entry. */
2487
2488 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2489 }
2490 }
2491 else
2492 {
2493 h->plt.offset = (bfd_vma) -1;
2494 h->needs_plt = 0;
2495 }
2496 }
2497 else
2498 {
2499 h->plt.offset = (bfd_vma) -1;
2500 h->needs_plt = 0;
2501 }
2502
2503 eh->tlsdesc_got = (bfd_vma) -1;
2504
2505 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2506 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2507 if (h->got.refcount > 0
2508 && bfd_link_executable (info)
2509 && h->dynindx == -1
2510 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2511 h->got.offset = (bfd_vma) -1;
2512 else if (h->got.refcount > 0)
2513 {
2514 asection *s;
2515 bfd_boolean dyn;
2516 int tls_type = elf_i386_hash_entry(h)->tls_type;
2517
2518 /* Make sure this symbol is output as a dynamic symbol.
2519 Undefined weak syms won't yet be marked as dynamic. */
2520 if (h->dynindx == -1
2521 && !h->forced_local)
2522 {
2523 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2524 return FALSE;
2525 }
2526
2527 s = htab->elf.sgot;
2528 if (GOT_TLS_GDESC_P (tls_type))
2529 {
2530 eh->tlsdesc_got = htab->elf.sgotplt->size
2531 - elf_i386_compute_jump_table_size (htab);
2532 htab->elf.sgotplt->size += 8;
2533 h->got.offset = (bfd_vma) -2;
2534 }
2535 if (! GOT_TLS_GDESC_P (tls_type)
2536 || GOT_TLS_GD_P (tls_type))
2537 {
2538 h->got.offset = s->size;
2539 s->size += 4;
2540 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2541 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2542 s->size += 4;
2543 }
2544 dyn = htab->elf.dynamic_sections_created;
2545 /* R_386_TLS_IE_32 needs one dynamic relocation,
2546 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2547 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2548 need two), R_386_TLS_GD needs one if local symbol and two if
2549 global. */
2550 if (tls_type == GOT_TLS_IE_BOTH)
2551 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2552 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2553 || (tls_type & GOT_TLS_IE))
2554 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2555 else if (GOT_TLS_GD_P (tls_type))
2556 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2557 else if (! GOT_TLS_GDESC_P (tls_type)
2558 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2559 || h->root.type != bfd_link_hash_undefweak)
2560 && (bfd_link_pic (info)
2561 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2562 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2563 if (GOT_TLS_GDESC_P (tls_type))
2564 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2565 }
2566 else
2567 h->got.offset = (bfd_vma) -1;
2568
2569 if (eh->dyn_relocs == NULL)
2570 return TRUE;
2571
2572 /* In the shared -Bsymbolic case, discard space allocated for
2573 dynamic pc-relative relocs against symbols which turn out to be
2574 defined in regular objects. For the normal shared case, discard
2575 space for pc-relative relocs that have become local due to symbol
2576 visibility changes. */
2577
2578 if (bfd_link_pic (info))
2579 {
2580 /* The only reloc that uses pc_count is R_386_PC32, which will
2581 appear on a call or on something like ".long foo - .". We
2582 want calls to protected symbols to resolve directly to the
2583 function rather than going via the plt. If people want
2584 function pointer comparisons to work as expected then they
2585 should avoid writing assembly like ".long foo - .". */
2586 if (SYMBOL_CALLS_LOCAL (info, h))
2587 {
2588 struct elf_dyn_relocs **pp;
2589
2590 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2591 {
2592 p->count -= p->pc_count;
2593 p->pc_count = 0;
2594 if (p->count == 0)
2595 *pp = p->next;
2596 else
2597 pp = &p->next;
2598 }
2599 }
2600
2601 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2602 {
2603 struct elf_dyn_relocs **pp;
2604 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2605 {
2606 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2607 *pp = p->next;
2608 else
2609 pp = &p->next;
2610 }
2611 }
2612
2613 /* Also discard relocs on undefined weak syms with non-default
2614 visibility. */
2615 if (eh->dyn_relocs != NULL
2616 && h->root.type == bfd_link_hash_undefweak)
2617 {
2618 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2619 eh->dyn_relocs = NULL;
2620
2621 /* Make sure undefined weak symbols are output as a dynamic
2622 symbol in PIEs. */
2623 else if (h->dynindx == -1
2624 && !h->forced_local)
2625 {
2626 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2627 return FALSE;
2628 }
2629 }
2630 }
2631 else if (ELIMINATE_COPY_RELOCS)
2632 {
2633 /* For the non-shared case, discard space for relocs against
2634 symbols which turn out to need copy relocs or are not
2635 dynamic. Keep dynamic relocations for run-time function
2636 pointer initialization. */
2637
2638 if ((!h->non_got_ref || eh->func_pointer_refcount > 0)
2639 && ((h->def_dynamic
2640 && !h->def_regular)
2641 || (htab->elf.dynamic_sections_created
2642 && (h->root.type == bfd_link_hash_undefweak
2643 || h->root.type == bfd_link_hash_undefined))))
2644 {
2645 /* Make sure this symbol is output as a dynamic symbol.
2646 Undefined weak syms won't yet be marked as dynamic. */
2647 if (h->dynindx == -1
2648 && !h->forced_local)
2649 {
2650 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2651 return FALSE;
2652 }
2653
2654 /* If that succeeded, we know we'll be keeping all the
2655 relocs. */
2656 if (h->dynindx != -1)
2657 goto keep;
2658 }
2659
2660 eh->dyn_relocs = NULL;
2661 eh->func_pointer_refcount = 0;
2662
2663 keep: ;
2664 }
2665
2666 /* Finally, allocate space. */
2667 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2668 {
2669 asection *sreloc;
2670
2671 sreloc = elf_section_data (p->sec)->sreloc;
2672
2673 BFD_ASSERT (sreloc != NULL);
2674 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2675 }
2676
2677 return TRUE;
2678 }
2679
2680 /* Allocate space in .plt, .got and associated reloc sections for
2681 local dynamic relocs. */
2682
2683 static bfd_boolean
2684 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2685 {
2686 struct elf_link_hash_entry *h
2687 = (struct elf_link_hash_entry *) *slot;
2688
2689 if (h->type != STT_GNU_IFUNC
2690 || !h->def_regular
2691 || !h->ref_regular
2692 || !h->forced_local
2693 || h->root.type != bfd_link_hash_defined)
2694 abort ();
2695
2696 return elf_i386_allocate_dynrelocs (h, inf);
2697 }
2698
2699 /* Find any dynamic relocs that apply to read-only sections. */
2700
2701 static bfd_boolean
2702 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2703 {
2704 struct elf_i386_link_hash_entry *eh;
2705 struct elf_dyn_relocs *p;
2706
2707 /* Skip local IFUNC symbols. */
2708 if (h->forced_local && h->type == STT_GNU_IFUNC)
2709 return TRUE;
2710
2711 eh = (struct elf_i386_link_hash_entry *) h;
2712 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2713 {
2714 asection *s = p->sec->output_section;
2715
2716 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2717 {
2718 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2719
2720 info->flags |= DF_TEXTREL;
2721
2722 if ((info->warn_shared_textrel && bfd_link_pic (info))
2723 || info->error_textrel)
2724 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2725 p->sec->owner, h->root.root.string,
2726 p->sec);
2727
2728 /* Not an error, just cut short the traversal. */
2729 return FALSE;
2730 }
2731 }
2732 return TRUE;
2733 }
2734
2735 /* With the local symbol, foo, we convert
2736 mov foo@GOT[(%reg1)], %reg2
2737 to
2738 lea foo[@GOTOFF(%reg1)], %reg2
2739 and convert
2740 call/jmp *foo@GOT[(%reg)]
2741 to
2742 nop call foo/jmp foo nop
2743 When PIC is false, convert
2744 test %reg1, foo@GOT[(%reg2)]
2745 to
2746 test $foo, %reg1
2747 and convert
2748 binop foo@GOT[(%reg1)], %reg2
2749 to
2750 binop $foo, %reg2
2751 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2752 instructions. */
2753
2754 static bfd_boolean
2755 elf_i386_convert_load (bfd *abfd, asection *sec,
2756 struct bfd_link_info *link_info)
2757 {
2758 Elf_Internal_Shdr *symtab_hdr;
2759 Elf_Internal_Rela *internal_relocs;
2760 Elf_Internal_Rela *irel, *irelend;
2761 bfd_byte *contents;
2762 struct elf_i386_link_hash_table *htab;
2763 bfd_boolean changed_contents;
2764 bfd_boolean changed_relocs;
2765 bfd_signed_vma *local_got_refcounts;
2766
2767 /* Don't even try to convert non-ELF outputs. */
2768 if (!is_elf_hash_table (link_info->hash))
2769 return FALSE;
2770
2771 /* Nothing to do if there is no need or no output. */
2772 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2773 || sec->need_convert_load == 0
2774 || bfd_is_abs_section (sec->output_section))
2775 return TRUE;
2776
2777 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2778
2779 /* Load the relocations for this section. */
2780 internal_relocs = (_bfd_elf_link_read_relocs
2781 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2782 link_info->keep_memory));
2783 if (internal_relocs == NULL)
2784 return FALSE;
2785
2786 htab = elf_i386_hash_table (link_info);
2787 changed_contents = FALSE;
2788 changed_relocs = FALSE;
2789 local_got_refcounts = elf_local_got_refcounts (abfd);
2790
2791 /* Get the section contents. */
2792 if (elf_section_data (sec)->this_hdr.contents != NULL)
2793 contents = elf_section_data (sec)->this_hdr.contents;
2794 else
2795 {
2796 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2797 goto error_return;
2798 }
2799
2800 irelend = internal_relocs + sec->reloc_count;
2801 for (irel = internal_relocs; irel < irelend; irel++)
2802 {
2803 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2804 unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2805 unsigned int indx;
2806 struct elf_link_hash_entry *h;
2807 unsigned int opcode;
2808 unsigned int modrm;
2809 bfd_vma roff;
2810 bfd_boolean baseless;
2811 Elf_Internal_Sym *isym;
2812 unsigned int addend;
2813 unsigned int nop;
2814 bfd_vma nop_offset;
2815
2816 if (r_type != R_386_GOT32 && r_type != R_386_GOT32X)
2817 continue;
2818
2819 roff = irel->r_offset;
2820 if (roff < 2)
2821 continue;
2822
2823 modrm = bfd_get_8 (abfd, contents + roff - 1);
2824 baseless = (modrm & 0xc7) == 0x5;
2825
2826 if (r_type == R_386_GOT32X
2827 && baseless
2828 && bfd_link_pic (link_info))
2829 {
2830 /* For PIC, disallow R_386_GOT32X without a base register
2831 since we don't know what the GOT base is. Allow
2832 R_386_GOT32 for existing object files. */
2833 const char *name;
2834
2835 if (r_symndx < symtab_hdr->sh_info)
2836 {
2837 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
2838 r_symndx);
2839 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
2840 }
2841 else
2842 {
2843 indx = r_symndx - symtab_hdr->sh_info;
2844 h = elf_sym_hashes (abfd)[indx];
2845 BFD_ASSERT (h != NULL);
2846 name = h->root.root.string;
2847 }
2848
2849 (*_bfd_error_handler)
2850 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
2851 abfd, name);
2852 goto error_return;
2853 }
2854
2855 opcode = bfd_get_8 (abfd, contents + roff - 2);
2856
2857 /* It is OK to convert mov to lea. */
2858 if (opcode != 0x8b)
2859 {
2860 /* Only convert R_386_GOT32X relocation for call, jmp or
2861 one of adc, add, and, cmp, or, sbb, sub, test, xor
2862 instructions. */
2863 if (r_type != R_386_GOT32X)
2864 continue;
2865
2866 /* It is OK to convert indirect branch to direct branch. It
2867 is OK to convert adc, add, and, cmp, or, sbb, sub, test,
2868 xor only when PIC is false. */
2869 if (opcode != 0xff && bfd_link_pic (link_info))
2870 continue;
2871 }
2872
2873 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
2874 referred to by the reloc. */
2875 if (r_symndx < symtab_hdr->sh_info)
2876 {
2877 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2878 abfd, r_symndx);
2879
2880 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2881 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2882 continue;
2883
2884 h = NULL;
2885 if (opcode == 0x0ff)
2886 /* Convert "call/jmp *foo@GOT[(%reg)]". */
2887 goto convert_branch;
2888 else
2889 /* Convert "mov foo@GOT[(%reg1)], %reg2",
2890 "test %reg1, foo@GOT(%reg2)" and
2891 "binop foo@GOT[(%reg1)], %reg2". */
2892 goto convert_load;
2893 }
2894
2895 indx = r_symndx - symtab_hdr->sh_info;
2896 h = elf_sym_hashes (abfd)[indx];
2897 BFD_ASSERT (h != NULL);
2898
2899 while (h->root.type == bfd_link_hash_indirect
2900 || h->root.type == bfd_link_hash_warning)
2901 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2902
2903 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2904 if (h->type == STT_GNU_IFUNC)
2905 continue;
2906
2907 if (opcode == 0xff)
2908 {
2909 /* We have "call/jmp *foo@GOT[(%reg)]". */
2910 if ((h->root.type == bfd_link_hash_defined
2911 || h->root.type == bfd_link_hash_defweak)
2912 && SYMBOL_REFERENCES_LOCAL (link_info, h))
2913 {
2914 /* The function is locally defined. */
2915 convert_branch:
2916 addend = bfd_get_32 (abfd, contents + roff);
2917 /* Addend for R_386_GOT32X relocation must be 0. */
2918 if (addend != 0)
2919 continue;
2920
2921 /* Convert R_386_GOT32X to R_386_PC32. */
2922 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
2923 {
2924 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2925 is a nop prefix. */
2926 modrm = 0xe8;
2927 nop = link_info->call_nop_byte;
2928 if (link_info->call_nop_as_suffix)
2929 {
2930 nop_offset = roff + 3;
2931 irel->r_offset -= 1;
2932 }
2933 else
2934 nop_offset = roff - 2;
2935 }
2936 else
2937 {
2938 /* Convert to "jmp foo nop". */
2939 modrm = 0xe9;
2940 nop = NOP_OPCODE;
2941 nop_offset = roff + 3;
2942 irel->r_offset -= 1;
2943 }
2944
2945 bfd_put_8 (abfd, nop, contents + nop_offset);
2946 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
2947 /* When converting to PC-relative relocation, we
2948 need to adjust addend by -4. */
2949 bfd_put_32 (abfd, -4, contents + irel->r_offset);
2950 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
2951
2952 if (h)
2953 {
2954 if (h->got.refcount > 0)
2955 h->got.refcount -= 1;
2956 }
2957 else
2958 {
2959 if (local_got_refcounts != NULL
2960 && local_got_refcounts[r_symndx] > 0)
2961 local_got_refcounts[r_symndx] -= 1;
2962 }
2963
2964 changed_contents = TRUE;
2965 changed_relocs = TRUE;
2966 }
2967 }
2968 else
2969 {
2970 /* We have "mov foo@GOT[(%re1g)], %reg2",
2971 "test %reg1, foo@GOT(%reg2)" and
2972 "binop foo@GOT[(%reg1)], %reg2".
2973
2974 Avoid optimizing _DYNAMIC since ld.so may use its
2975 link-time address. */
2976 if (h == htab->elf.hdynamic)
2977 continue;
2978
2979 /* bfd_link_hash_new is set by an assignment in a linker
2980 script in bfd_elf_record_link_assignment. */
2981 if ((h->root.type == bfd_link_hash_defined
2982 || h->root.type == bfd_link_hash_defweak
2983 || h->root.type == bfd_link_hash_new)
2984 && SYMBOL_REFERENCES_LOCAL (link_info, h))
2985 {
2986 convert_load:
2987 if (opcode == 0x8b)
2988 {
2989 /* Convert "mov foo@GOT(%reg1), %reg2" to
2990 "lea foo@GOTOFF(%reg1), %reg2". */
2991 if (r_type == R_386_GOT32X
2992 && (baseless || !bfd_link_pic (link_info)))
2993 {
2994 r_type = R_386_32;
2995 /* For R_386_32, convert
2996 "lea foo@GOTOFF(%reg1), %reg2" to
2997 "lea foo@GOT, %reg2". */
2998 if (!baseless)
2999 {
3000 modrm = 0x5 | (modrm & 0x38);
3001 bfd_put_8 (abfd, modrm, contents + roff - 1);
3002 }
3003 }
3004 else
3005 r_type = R_386_GOTOFF;
3006 opcode = 0x8d;
3007 }
3008 else
3009 {
3010 /* Addend for R_386_GOT32X relocation must be 0. */
3011 addend = bfd_get_32 (abfd, contents + roff);
3012 if (addend != 0)
3013 continue;
3014
3015 if (opcode == 0x85)
3016 {
3017 /* Convert "test %reg1, foo@GOT(%reg2)" to
3018 "test $foo, %reg1". */
3019 modrm = 0xc0 | (modrm & 0x38) >> 3;
3020 opcode = 0xf7;
3021 }
3022 else
3023 {
3024 /* Convert "binop foo@GOT(%reg1), %reg2" to
3025 "binop $foo, %reg2". */
3026 modrm = (0xc0
3027 | (modrm & 0x38) >> 3
3028 | (opcode & 0x3c));
3029 opcode = 0x81;
3030 }
3031 bfd_put_8 (abfd, modrm, contents + roff - 1);
3032 r_type = R_386_32;
3033 }
3034
3035 bfd_put_8 (abfd, opcode, contents + roff - 2);
3036 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
3037
3038 if (h)
3039 {
3040 if (h->got.refcount > 0)
3041 h->got.refcount -= 1;
3042 }
3043 else
3044 {
3045 if (local_got_refcounts != NULL
3046 && local_got_refcounts[r_symndx] > 0)
3047 local_got_refcounts[r_symndx] -= 1;
3048 }
3049
3050 changed_contents = TRUE;
3051 changed_relocs = TRUE;
3052 }
3053 }
3054 }
3055
3056 if (contents != NULL
3057 && elf_section_data (sec)->this_hdr.contents != contents)
3058 {
3059 if (!changed_contents && !link_info->keep_memory)
3060 free (contents);
3061 else
3062 {
3063 /* Cache the section contents for elf_link_input_bfd. */
3064 elf_section_data (sec)->this_hdr.contents = contents;
3065 }
3066 }
3067
3068 if (elf_section_data (sec)->relocs != internal_relocs)
3069 {
3070 if (!changed_relocs)
3071 free (internal_relocs);
3072 else
3073 elf_section_data (sec)->relocs = internal_relocs;
3074 }
3075
3076 return TRUE;
3077
3078 error_return:
3079 if (contents != NULL
3080 && elf_section_data (sec)->this_hdr.contents != contents)
3081 free (contents);
3082 if (internal_relocs != NULL
3083 && elf_section_data (sec)->relocs != internal_relocs)
3084 free (internal_relocs);
3085 return FALSE;
3086 }
3087
3088 /* Set the sizes of the dynamic sections. */
3089
3090 static bfd_boolean
3091 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3092 {
3093 struct elf_i386_link_hash_table *htab;
3094 bfd *dynobj;
3095 asection *s;
3096 bfd_boolean relocs;
3097 bfd *ibfd;
3098
3099 htab = elf_i386_hash_table (info);
3100 if (htab == NULL)
3101 return FALSE;
3102 dynobj = htab->elf.dynobj;
3103 if (dynobj == NULL)
3104 abort ();
3105
3106 if (htab->elf.dynamic_sections_created)
3107 {
3108 /* Set the contents of the .interp section to the interpreter. */
3109 if (bfd_link_executable (info) && !info->nointerp)
3110 {
3111 s = bfd_get_linker_section (dynobj, ".interp");
3112 if (s == NULL)
3113 abort ();
3114 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3115 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3116 }
3117 }
3118
3119 /* Set up .got offsets for local syms, and space for local dynamic
3120 relocs. */
3121 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3122 {
3123 bfd_signed_vma *local_got;
3124 bfd_signed_vma *end_local_got;
3125 char *local_tls_type;
3126 bfd_vma *local_tlsdesc_gotent;
3127 bfd_size_type locsymcount;
3128 Elf_Internal_Shdr *symtab_hdr;
3129 asection *srel;
3130
3131 if (! is_i386_elf (ibfd))
3132 continue;
3133
3134 for (s = ibfd->sections; s != NULL; s = s->next)
3135 {
3136 struct elf_dyn_relocs *p;
3137
3138 if (!elf_i386_convert_load (ibfd, s, info))
3139 return FALSE;
3140
3141 for (p = ((struct elf_dyn_relocs *)
3142 elf_section_data (s)->local_dynrel);
3143 p != NULL;
3144 p = p->next)
3145 {
3146 if (!bfd_is_abs_section (p->sec)
3147 && bfd_is_abs_section (p->sec->output_section))
3148 {
3149 /* Input section has been discarded, either because
3150 it is a copy of a linkonce section or due to
3151 linker script /DISCARD/, so we'll be discarding
3152 the relocs too. */
3153 }
3154 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3155 && strcmp (p->sec->output_section->name,
3156 ".tls_vars") == 0)
3157 {
3158 /* Relocations in vxworks .tls_vars sections are
3159 handled specially by the loader. */
3160 }
3161 else if (p->count != 0)
3162 {
3163 srel = elf_section_data (p->sec)->sreloc;
3164 srel->size += p->count * sizeof (Elf32_External_Rel);
3165 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3166 && (info->flags & DF_TEXTREL) == 0)
3167 {
3168 info->flags |= DF_TEXTREL;
3169 if ((info->warn_shared_textrel && bfd_link_pic (info))
3170 || info->error_textrel)
3171 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3172 p->sec->owner, p->sec);
3173 }
3174 }
3175 }
3176 }
3177
3178 local_got = elf_local_got_refcounts (ibfd);
3179 if (!local_got)
3180 continue;
3181
3182 symtab_hdr = &elf_symtab_hdr (ibfd);
3183 locsymcount = symtab_hdr->sh_info;
3184 end_local_got = local_got + locsymcount;
3185 local_tls_type = elf_i386_local_got_tls_type (ibfd);
3186 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
3187 s = htab->elf.sgot;
3188 srel = htab->elf.srelgot;
3189 for (; local_got < end_local_got;
3190 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3191 {
3192 *local_tlsdesc_gotent = (bfd_vma) -1;
3193 if (*local_got > 0)
3194 {
3195 if (GOT_TLS_GDESC_P (*local_tls_type))
3196 {
3197 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3198 - elf_i386_compute_jump_table_size (htab);
3199 htab->elf.sgotplt->size += 8;
3200 *local_got = (bfd_vma) -2;
3201 }
3202 if (! GOT_TLS_GDESC_P (*local_tls_type)
3203 || GOT_TLS_GD_P (*local_tls_type))
3204 {
3205 *local_got = s->size;
3206 s->size += 4;
3207 if (GOT_TLS_GD_P (*local_tls_type)
3208 || *local_tls_type == GOT_TLS_IE_BOTH)
3209 s->size += 4;
3210 }
3211 if (bfd_link_pic (info)
3212 || GOT_TLS_GD_ANY_P (*local_tls_type)
3213 || (*local_tls_type & GOT_TLS_IE))
3214 {
3215 if (*local_tls_type == GOT_TLS_IE_BOTH)
3216 srel->size += 2 * sizeof (Elf32_External_Rel);
3217 else if (GOT_TLS_GD_P (*local_tls_type)
3218 || ! GOT_TLS_GDESC_P (*local_tls_type))
3219 srel->size += sizeof (Elf32_External_Rel);
3220 if (GOT_TLS_GDESC_P (*local_tls_type))
3221 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
3222 }
3223 }
3224 else
3225 *local_got = (bfd_vma) -1;
3226 }
3227 }
3228
3229 if (htab->tls_ldm_got.refcount > 0)
3230 {
3231 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3232 relocs. */
3233 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3234 htab->elf.sgot->size += 8;
3235 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
3236 }
3237 else
3238 htab->tls_ldm_got.offset = -1;
3239
3240 /* Allocate global sym .plt and .got entries, and space for global
3241 sym dynamic relocs. */
3242 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
3243
3244 /* Allocate .plt and .got entries, and space for local symbols. */
3245 htab_traverse (htab->loc_hash_table,
3246 elf_i386_allocate_local_dynrelocs,
3247 info);
3248
3249 /* For every jump slot reserved in the sgotplt, reloc_count is
3250 incremented. However, when we reserve space for TLS descriptors,
3251 it's not incremented, so in order to compute the space reserved
3252 for them, it suffices to multiply the reloc count by the jump
3253 slot size.
3254
3255 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3256 so that R_386_IRELATIVE entries come last. */
3257 if (htab->elf.srelplt)
3258 {
3259 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3260 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3261 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3262 }
3263 else if (htab->elf.irelplt)
3264 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3265
3266
3267 if (htab->elf.sgotplt)
3268 {
3269 /* Don't allocate .got.plt section if there are no GOT nor PLT
3270 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3271 if ((htab->elf.hgot == NULL
3272 || !htab->elf.hgot->ref_regular_nonweak)
3273 && (htab->elf.sgotplt->size
3274 == get_elf_backend_data (output_bfd)->got_header_size)
3275 && (htab->elf.splt == NULL
3276 || htab->elf.splt->size == 0)
3277 && (htab->elf.sgot == NULL
3278 || htab->elf.sgot->size == 0)
3279 && (htab->elf.iplt == NULL
3280 || htab->elf.iplt->size == 0)
3281 && (htab->elf.igotplt == NULL
3282 || htab->elf.igotplt->size == 0))
3283 htab->elf.sgotplt->size = 0;
3284 }
3285
3286
3287 if (htab->plt_eh_frame != NULL
3288 && htab->elf.splt != NULL
3289 && htab->elf.splt->size != 0
3290 && !bfd_is_abs_section (htab->elf.splt->output_section)
3291 && _bfd_elf_eh_frame_present (info))
3292 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3293
3294 /* We now have determined the sizes of the various dynamic sections.
3295 Allocate memory for them. */
3296 relocs = FALSE;
3297 for (s = dynobj->sections; s != NULL; s = s->next)
3298 {
3299 bfd_boolean strip_section = TRUE;
3300
3301 if ((s->flags & SEC_LINKER_CREATED) == 0)
3302 continue;
3303
3304 if (s == htab->elf.splt
3305 || s == htab->elf.sgot)
3306 {
3307 /* Strip this section if we don't need it; see the
3308 comment below. */
3309 /* We'd like to strip these sections if they aren't needed, but if
3310 we've exported dynamic symbols from them we must leave them.
3311 It's too late to tell BFD to get rid of the symbols. */
3312
3313 if (htab->elf.hplt != NULL)
3314 strip_section = FALSE;
3315 }
3316 else if (s == htab->elf.sgotplt
3317 || s == htab->elf.iplt
3318 || s == htab->elf.igotplt
3319 || s == htab->plt_got
3320 || s == htab->plt_eh_frame
3321 || s == htab->sdynbss)
3322 {
3323 /* Strip these too. */
3324 }
3325 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3326 {
3327 if (s->size != 0
3328 && s != htab->elf.srelplt
3329 && s != htab->srelplt2)
3330 relocs = TRUE;
3331
3332 /* We use the reloc_count field as a counter if we need
3333 to copy relocs into the output file. */
3334 s->reloc_count = 0;
3335 }
3336 else
3337 {
3338 /* It's not one of our sections, so don't allocate space. */
3339 continue;
3340 }
3341
3342 if (s->size == 0)
3343 {
3344 /* If we don't need this section, strip it from the
3345 output file. This is mostly to handle .rel.bss and
3346 .rel.plt. We must create both sections in
3347 create_dynamic_sections, because they must be created
3348 before the linker maps input sections to output
3349 sections. The linker does that before
3350 adjust_dynamic_symbol is called, and it is that
3351 function which decides whether anything needs to go
3352 into these sections. */
3353 if (strip_section)
3354 s->flags |= SEC_EXCLUDE;
3355 continue;
3356 }
3357
3358 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3359 continue;
3360
3361 /* Allocate memory for the section contents. We use bfd_zalloc
3362 here in case unused entries are not reclaimed before the
3363 section's contents are written out. This should not happen,
3364 but this way if it does, we get a R_386_NONE reloc instead
3365 of garbage. */
3366 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3367 if (s->contents == NULL)
3368 return FALSE;
3369 }
3370
3371 if (htab->plt_eh_frame != NULL
3372 && htab->plt_eh_frame->contents != NULL)
3373 {
3374 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3375 sizeof (elf_i386_eh_frame_plt));
3376 bfd_put_32 (dynobj, htab->elf.splt->size,
3377 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3378 }
3379
3380 if (htab->elf.dynamic_sections_created)
3381 {
3382 /* Add some entries to the .dynamic section. We fill in the
3383 values later, in elf_i386_finish_dynamic_sections, but we
3384 must add the entries now so that we get the correct size for
3385 the .dynamic section. The DT_DEBUG entry is filled in by the
3386 dynamic linker and used by the debugger. */
3387 #define add_dynamic_entry(TAG, VAL) \
3388 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3389
3390 if (bfd_link_executable (info))
3391 {
3392 if (!add_dynamic_entry (DT_DEBUG, 0))
3393 return FALSE;
3394 }
3395
3396 if (htab->elf.splt->size != 0)
3397 {
3398 /* DT_PLTGOT is used by prelink even if there is no PLT
3399 relocation. */
3400 if (!add_dynamic_entry (DT_PLTGOT, 0))
3401 return FALSE;
3402
3403 if (htab->elf.srelplt->size != 0)
3404 {
3405 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3406 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3407 || !add_dynamic_entry (DT_JMPREL, 0))
3408 return FALSE;
3409 }
3410 }
3411
3412 if (relocs)
3413 {
3414 if (!add_dynamic_entry (DT_REL, 0)
3415 || !add_dynamic_entry (DT_RELSZ, 0)
3416 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3417 return FALSE;
3418
3419 /* If any dynamic relocs apply to a read-only section,
3420 then we need a DT_TEXTREL entry. */
3421 if ((info->flags & DF_TEXTREL) == 0)
3422 elf_link_hash_traverse (&htab->elf,
3423 elf_i386_readonly_dynrelocs, info);
3424
3425 if ((info->flags & DF_TEXTREL) != 0)
3426 {
3427 if ((elf_tdata (output_bfd)->has_gnu_symbols
3428 & elf_gnu_symbol_ifunc) == elf_gnu_symbol_ifunc)
3429 {
3430 info->callbacks->einfo
3431 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3432 bfd_set_error (bfd_error_bad_value);
3433 return FALSE;
3434 }
3435
3436 if (!add_dynamic_entry (DT_TEXTREL, 0))
3437 return FALSE;
3438 }
3439 }
3440 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3441 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3442 return FALSE;
3443 }
3444 #undef add_dynamic_entry
3445
3446 return TRUE;
3447 }
3448
3449 static bfd_boolean
3450 elf_i386_always_size_sections (bfd *output_bfd,
3451 struct bfd_link_info *info)
3452 {
3453 asection *tls_sec = elf_hash_table (info)->tls_sec;
3454
3455 if (tls_sec)
3456 {
3457 struct elf_link_hash_entry *tlsbase;
3458
3459 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3460 "_TLS_MODULE_BASE_",
3461 FALSE, FALSE, FALSE);
3462
3463 if (tlsbase && tlsbase->type == STT_TLS)
3464 {
3465 struct elf_i386_link_hash_table *htab;
3466 struct bfd_link_hash_entry *bh = NULL;
3467 const struct elf_backend_data *bed
3468 = get_elf_backend_data (output_bfd);
3469
3470 htab = elf_i386_hash_table (info);
3471 if (htab == NULL)
3472 return FALSE;
3473
3474 if (!(_bfd_generic_link_add_one_symbol
3475 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3476 tls_sec, 0, NULL, FALSE,
3477 bed->collect, &bh)))
3478 return FALSE;
3479
3480 htab->tls_module_base = bh;
3481
3482 tlsbase = (struct elf_link_hash_entry *)bh;
3483 tlsbase->def_regular = 1;
3484 tlsbase->other = STV_HIDDEN;
3485 tlsbase->root.linker_def = 1;
3486 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3487 }
3488 }
3489
3490 return TRUE;
3491 }
3492
3493 /* Set the correct type for an x86 ELF section. We do this by the
3494 section name, which is a hack, but ought to work. */
3495
3496 static bfd_boolean
3497 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3498 Elf_Internal_Shdr *hdr,
3499 asection *sec)
3500 {
3501 const char *name;
3502
3503 name = bfd_get_section_name (abfd, sec);
3504
3505 /* This is an ugly, but unfortunately necessary hack that is
3506 needed when producing EFI binaries on x86. It tells
3507 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3508 containing ELF relocation info. We need this hack in order to
3509 be able to generate ELF binaries that can be translated into
3510 EFI applications (which are essentially COFF objects). Those
3511 files contain a COFF ".reloc" section inside an ELFNN object,
3512 which would normally cause BFD to segfault because it would
3513 attempt to interpret this section as containing relocation
3514 entries for section "oc". With this hack enabled, ".reloc"
3515 will be treated as a normal data section, which will avoid the
3516 segfault. However, you won't be able to create an ELFNN binary
3517 with a section named "oc" that needs relocations, but that's
3518 the kind of ugly side-effects you get when detecting section
3519 types based on their names... In practice, this limitation is
3520 unlikely to bite. */
3521 if (strcmp (name, ".reloc") == 0)
3522 hdr->sh_type = SHT_PROGBITS;
3523
3524 return TRUE;
3525 }
3526
3527 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3528 executables. Rather than setting it to the beginning of the TLS
3529 section, we have to set it to the end. This function may be called
3530 multiple times, it is idempotent. */
3531
3532 static void
3533 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3534 {
3535 struct elf_i386_link_hash_table *htab;
3536 struct bfd_link_hash_entry *base;
3537
3538 if (!bfd_link_executable (info))
3539 return;
3540
3541 htab = elf_i386_hash_table (info);
3542 if (htab == NULL)
3543 return;
3544
3545 base = htab->tls_module_base;
3546 if (base == NULL)
3547 return;
3548
3549 base->u.def.value = htab->elf.tls_size;
3550 }
3551
3552 /* Return the base VMA address which should be subtracted from real addresses
3553 when resolving @dtpoff relocation.
3554 This is PT_TLS segment p_vaddr. */
3555
3556 static bfd_vma
3557 elf_i386_dtpoff_base (struct bfd_link_info *info)
3558 {
3559 /* If tls_sec is NULL, we should have signalled an error already. */
3560 if (elf_hash_table (info)->tls_sec == NULL)
3561 return 0;
3562 return elf_hash_table (info)->tls_sec->vma;
3563 }
3564
3565 /* Return the relocation value for @tpoff relocation
3566 if STT_TLS virtual address is ADDRESS. */
3567
3568 static bfd_vma
3569 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3570 {
3571 struct elf_link_hash_table *htab = elf_hash_table (info);
3572 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3573 bfd_vma static_tls_size;
3574
3575 /* If tls_sec is NULL, we should have signalled an error already. */
3576 if (htab->tls_sec == NULL)
3577 return 0;
3578
3579 /* Consider special static TLS alignment requirements. */
3580 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3581 return static_tls_size + htab->tls_sec->vma - address;
3582 }
3583
3584 /* Relocate an i386 ELF section. */
3585
3586 static bfd_boolean
3587 elf_i386_relocate_section (bfd *output_bfd,
3588 struct bfd_link_info *info,
3589 bfd *input_bfd,
3590 asection *input_section,
3591 bfd_byte *contents,
3592 Elf_Internal_Rela *relocs,
3593 Elf_Internal_Sym *local_syms,
3594 asection **local_sections)
3595 {
3596 struct elf_i386_link_hash_table *htab;
3597 Elf_Internal_Shdr *symtab_hdr;
3598 struct elf_link_hash_entry **sym_hashes;
3599 bfd_vma *local_got_offsets;
3600 bfd_vma *local_tlsdesc_gotents;
3601 Elf_Internal_Rela *rel;
3602 Elf_Internal_Rela *wrel;
3603 Elf_Internal_Rela *relend;
3604 bfd_boolean is_vxworks_tls;
3605 unsigned plt_entry_size;
3606
3607 BFD_ASSERT (is_i386_elf (input_bfd));
3608
3609 htab = elf_i386_hash_table (info);
3610 if (htab == NULL)
3611 return FALSE;
3612 symtab_hdr = &elf_symtab_hdr (input_bfd);
3613 sym_hashes = elf_sym_hashes (input_bfd);
3614 local_got_offsets = elf_local_got_offsets (input_bfd);
3615 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3616 /* We have to handle relocations in vxworks .tls_vars sections
3617 specially, because the dynamic loader is 'weird'. */
3618 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3619 && bfd_link_pic (info)
3620 && !strcmp (input_section->output_section->name,
3621 ".tls_vars"));
3622
3623 elf_i386_set_tls_module_base (info);
3624
3625 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3626
3627 rel = wrel = relocs;
3628 relend = relocs + input_section->reloc_count;
3629 for (; rel < relend; wrel++, rel++)
3630 {
3631 unsigned int r_type;
3632 reloc_howto_type *howto;
3633 unsigned long r_symndx;
3634 struct elf_link_hash_entry *h;
3635 struct elf_i386_link_hash_entry *eh;
3636 Elf_Internal_Sym *sym;
3637 asection *sec;
3638 bfd_vma off, offplt, plt_offset;
3639 bfd_vma relocation;
3640 bfd_boolean unresolved_reloc;
3641 bfd_reloc_status_type r;
3642 unsigned int indx;
3643 int tls_type;
3644 bfd_vma st_size;
3645 asection *resolved_plt;
3646
3647 r_type = ELF32_R_TYPE (rel->r_info);
3648 if (r_type == R_386_GNU_VTINHERIT
3649 || r_type == R_386_GNU_VTENTRY)
3650 continue;
3651
3652 if ((indx = r_type) >= R_386_standard
3653 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3654 >= R_386_ext - R_386_standard)
3655 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3656 >= R_386_ext2 - R_386_ext))
3657 {
3658 (*_bfd_error_handler)
3659 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3660 input_bfd, input_section, r_type);
3661 bfd_set_error (bfd_error_bad_value);
3662 return FALSE;
3663 }
3664 howto = elf_howto_table + indx;
3665
3666 r_symndx = ELF32_R_SYM (rel->r_info);
3667 h = NULL;
3668 sym = NULL;
3669 sec = NULL;
3670 unresolved_reloc = FALSE;
3671 if (r_symndx < symtab_hdr->sh_info)
3672 {
3673 sym = local_syms + r_symndx;
3674 sec = local_sections[r_symndx];
3675 relocation = (sec->output_section->vma
3676 + sec->output_offset
3677 + sym->st_value);
3678 st_size = sym->st_size;
3679
3680 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3681 && ((sec->flags & SEC_MERGE) != 0
3682 || (bfd_link_relocatable (info)
3683 && sec->output_offset != 0)))
3684 {
3685 bfd_vma addend;
3686 bfd_byte *where = contents + rel->r_offset;
3687
3688 switch (howto->size)
3689 {
3690 case 0:
3691 addend = bfd_get_8 (input_bfd, where);
3692 if (howto->pc_relative)
3693 {
3694 addend = (addend ^ 0x80) - 0x80;
3695 addend += 1;
3696 }
3697 break;
3698 case 1:
3699 addend = bfd_get_16 (input_bfd, where);
3700 if (howto->pc_relative)
3701 {
3702 addend = (addend ^ 0x8000) - 0x8000;
3703 addend += 2;
3704 }
3705 break;
3706 case 2:
3707 addend = bfd_get_32 (input_bfd, where);
3708 if (howto->pc_relative)
3709 {
3710 addend = (addend ^ 0x80000000) - 0x80000000;
3711 addend += 4;
3712 }
3713 break;
3714 default:
3715 abort ();
3716 }
3717
3718 if (bfd_link_relocatable (info))
3719 addend += sec->output_offset;
3720 else
3721 {
3722 asection *msec = sec;
3723 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3724 addend);
3725 addend -= relocation;
3726 addend += msec->output_section->vma + msec->output_offset;
3727 }
3728
3729 switch (howto->size)
3730 {
3731 case 0:
3732 /* FIXME: overflow checks. */
3733 if (howto->pc_relative)
3734 addend -= 1;
3735 bfd_put_8 (input_bfd, addend, where);
3736 break;
3737 case 1:
3738 if (howto->pc_relative)
3739 addend -= 2;
3740 bfd_put_16 (input_bfd, addend, where);
3741 break;
3742 case 2:
3743 if (howto->pc_relative)
3744 addend -= 4;
3745 bfd_put_32 (input_bfd, addend, where);
3746 break;
3747 }
3748 }
3749 else if (!bfd_link_relocatable (info)
3750 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3751 {
3752 /* Relocate against local STT_GNU_IFUNC symbol. */
3753 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3754 FALSE);
3755 if (h == NULL)
3756 abort ();
3757
3758 /* Set STT_GNU_IFUNC symbol value. */
3759 h->root.u.def.value = sym->st_value;
3760 h->root.u.def.section = sec;
3761 }
3762 }
3763 else
3764 {
3765 bfd_boolean warned ATTRIBUTE_UNUSED;
3766 bfd_boolean ignored ATTRIBUTE_UNUSED;
3767
3768 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3769 r_symndx, symtab_hdr, sym_hashes,
3770 h, sec, relocation,
3771 unresolved_reloc, warned, ignored);
3772 st_size = h->size;
3773 }
3774
3775 if (sec != NULL && discarded_section (sec))
3776 {
3777 _bfd_clear_contents (howto, input_bfd, input_section,
3778 contents + rel->r_offset);
3779 wrel->r_offset = rel->r_offset;
3780 wrel->r_info = 0;
3781 wrel->r_addend = 0;
3782
3783 /* For ld -r, remove relocations in debug sections against
3784 sections defined in discarded sections. Not done for
3785 eh_frame editing code expects to be present. */
3786 if (bfd_link_relocatable (info)
3787 && (input_section->flags & SEC_DEBUGGING))
3788 wrel--;
3789
3790 continue;
3791 }
3792
3793 if (bfd_link_relocatable (info))
3794 continue;
3795
3796 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3797 it here if it is defined in a non-shared object. */
3798 if (h != NULL
3799 && h->type == STT_GNU_IFUNC
3800 && h->def_regular)
3801 {
3802 asection *plt, *gotplt, *base_got;
3803 bfd_vma plt_index;
3804 const char *name;
3805
3806 if ((input_section->flags & SEC_ALLOC) == 0)
3807 {
3808 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3809 sections because such sections are not SEC_ALLOC and
3810 thus ld.so will not process them. */
3811 if ((input_section->flags & SEC_DEBUGGING) != 0)
3812 continue;
3813 abort ();
3814 }
3815 else if (h->plt.offset == (bfd_vma) -1)
3816 abort ();
3817
3818 /* STT_GNU_IFUNC symbol must go through PLT. */
3819 if (htab->elf.splt != NULL)
3820 {
3821 plt = htab->elf.splt;
3822 gotplt = htab->elf.sgotplt;
3823 }
3824 else
3825 {
3826 plt = htab->elf.iplt;
3827 gotplt = htab->elf.igotplt;
3828 }
3829
3830 relocation = (plt->output_section->vma
3831 + plt->output_offset + h->plt.offset);
3832
3833 switch (r_type)
3834 {
3835 default:
3836 if (h->root.root.string)
3837 name = h->root.root.string;
3838 else
3839 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3840 NULL);
3841 (*_bfd_error_handler)
3842 (_("%B: relocation %s against STT_GNU_IFUNC "
3843 "symbol `%s' isn't handled by %s"), input_bfd,
3844 elf_howto_table[r_type].name,
3845 name, __FUNCTION__);
3846 bfd_set_error (bfd_error_bad_value);
3847 return FALSE;
3848
3849 case R_386_32:
3850 /* Generate dynamic relcoation only when there is a
3851 non-GOT reference in a shared object. */
3852 if (bfd_link_pic (info) && h->non_got_ref)
3853 {
3854 Elf_Internal_Rela outrel;
3855 asection *sreloc;
3856 bfd_vma offset;
3857
3858 /* Need a dynamic relocation to get the real function
3859 adddress. */
3860 offset = _bfd_elf_section_offset (output_bfd,
3861 info,
3862 input_section,
3863 rel->r_offset);
3864 if (offset == (bfd_vma) -1
3865 || offset == (bfd_vma) -2)
3866 abort ();
3867
3868 outrel.r_offset = (input_section->output_section->vma
3869 + input_section->output_offset
3870 + offset);
3871
3872 if (h->dynindx == -1
3873 || h->forced_local
3874 || bfd_link_executable (info))
3875 {
3876 /* This symbol is resolved locally. */
3877 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3878 bfd_put_32 (output_bfd,
3879 (h->root.u.def.value
3880 + h->root.u.def.section->output_section->vma
3881 + h->root.u.def.section->output_offset),
3882 contents + offset);
3883 }
3884 else
3885 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3886
3887 sreloc = htab->elf.irelifunc;
3888 elf_append_rel (output_bfd, sreloc, &outrel);
3889
3890 /* If this reloc is against an external symbol, we
3891 do not want to fiddle with the addend. Otherwise,
3892 we need to include the symbol value so that it
3893 becomes an addend for the dynamic reloc. For an
3894 internal symbol, we have updated addend. */
3895 continue;
3896 }
3897 /* FALLTHROUGH */
3898 case R_386_PC32:
3899 case R_386_PLT32:
3900 goto do_relocation;
3901
3902 case R_386_GOT32:
3903 case R_386_GOT32X:
3904 base_got = htab->elf.sgot;
3905 off = h->got.offset;
3906
3907 if (base_got == NULL)
3908 abort ();
3909
3910 if (off == (bfd_vma) -1)
3911 {
3912 /* We can't use h->got.offset here to save state, or
3913 even just remember the offset, as finish_dynamic_symbol
3914 would use that as offset into .got. */
3915
3916 if (htab->elf.splt != NULL)
3917 {
3918 plt_index = h->plt.offset / plt_entry_size - 1;
3919 off = (plt_index + 3) * 4;
3920 base_got = htab->elf.sgotplt;
3921 }
3922 else
3923 {
3924 plt_index = h->plt.offset / plt_entry_size;
3925 off = plt_index * 4;
3926 base_got = htab->elf.igotplt;
3927 }
3928
3929 if (h->dynindx == -1
3930 || h->forced_local
3931 || info->symbolic)
3932 {
3933 /* This references the local defitionion. We must
3934 initialize this entry in the global offset table.
3935 Since the offset must always be a multiple of 8,
3936 we use the least significant bit to record
3937 whether we have initialized it already.
3938
3939 When doing a dynamic link, we create a .rela.got
3940 relocation entry to initialize the value. This
3941 is done in the finish_dynamic_symbol routine. */
3942 if ((off & 1) != 0)
3943 off &= ~1;
3944 else
3945 {
3946 bfd_put_32 (output_bfd, relocation,
3947 base_got->contents + off);
3948 h->got.offset |= 1;
3949 }
3950 }
3951
3952 relocation = off;
3953
3954 /* Adjust for static executables. */
3955 if (htab->elf.splt == NULL)
3956 relocation += gotplt->output_offset;
3957 }
3958 else
3959 {
3960 relocation = (base_got->output_section->vma
3961 + base_got->output_offset + off
3962 - gotplt->output_section->vma
3963 - gotplt->output_offset);
3964 /* Adjust for static executables. */
3965 if (htab->elf.splt == NULL)
3966 relocation += gotplt->output_offset;
3967 }
3968
3969 goto do_relocation;
3970
3971 case R_386_GOTOFF:
3972 relocation -= (gotplt->output_section->vma
3973 + gotplt->output_offset);
3974 goto do_relocation;
3975 }
3976 }
3977
3978 eh = (struct elf_i386_link_hash_entry *) h;
3979 switch (r_type)
3980 {
3981 case R_386_GOT32X:
3982 /* Avoid optimizing _DYNAMIC since ld.so may use its
3983 link-time address. */
3984 if (h == htab->elf.hdynamic)
3985 goto r_386_got32;
3986
3987 if (bfd_link_pic (info))
3988 {
3989 /* It is OK to convert mov to lea and convert indirect
3990 branch to direct branch. It is OK to convert adc,
3991 add, and, cmp, or, sbb, sub, test, xor only when PIC
3992 is false. */
3993 unsigned int opcode;
3994 opcode = bfd_get_8 (abfd, contents + rel->r_offset - 2);
3995 if (opcode != 0x8b && opcode != 0xff)
3996 goto r_386_got32;
3997 }
3998
3999 /* Resolve "mov GOT[(%reg)], %reg",
4000 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4001 and "binop foo@GOT[(%reg)], %reg". */
4002 if (h == NULL
4003 || (h->plt.offset == (bfd_vma) -1
4004 && h->got.offset == (bfd_vma) -1)
4005 || htab->elf.sgotplt == NULL)
4006 abort ();
4007
4008 offplt = (htab->elf.sgotplt->output_section->vma
4009 + htab->elf.sgotplt->output_offset);
4010
4011 /* It is relative to .got.plt section. */
4012 if (h->got.offset != (bfd_vma) -1)
4013 /* Use GOT entry. */
4014 relocation = (htab->elf.sgot->output_section->vma
4015 + htab->elf.sgot->output_offset
4016 + h->got.offset - offplt);
4017 else
4018 /* Use GOTPLT entry. */
4019 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4020
4021 if (!bfd_link_pic (info))
4022 {
4023 /* If not PIC, add the .got.plt section address for
4024 baseless addressing. */
4025 unsigned int modrm;
4026 modrm = bfd_get_8 (abfd, contents + rel->r_offset - 1);
4027 if ((modrm & 0xc7) == 0x5)
4028 relocation += offplt;
4029 }
4030
4031 unresolved_reloc = FALSE;
4032 break;
4033
4034 case R_386_GOT32:
4035 r_386_got32:
4036 /* Relocation is to the entry for this symbol in the global
4037 offset table. */
4038 if (htab->elf.sgot == NULL)
4039 abort ();
4040
4041 if (h != NULL)
4042 {
4043 bfd_boolean dyn;
4044
4045 off = h->got.offset;
4046 dyn = htab->elf.dynamic_sections_created;
4047 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4048 bfd_link_pic (info),
4049 h)
4050 || (bfd_link_pic (info)
4051 && SYMBOL_REFERENCES_LOCAL (info, h))
4052 || (ELF_ST_VISIBILITY (h->other)
4053 && h->root.type == bfd_link_hash_undefweak))
4054 {
4055 /* This is actually a static link, or it is a
4056 -Bsymbolic link and the symbol is defined
4057 locally, or the symbol was forced to be local
4058 because of a version file. We must initialize
4059 this entry in the global offset table. Since the
4060 offset must always be a multiple of 4, we use the
4061 least significant bit to record whether we have
4062 initialized it already.
4063
4064 When doing a dynamic link, we create a .rel.got
4065 relocation entry to initialize the value. This
4066 is done in the finish_dynamic_symbol routine. */
4067 if ((off & 1) != 0)
4068 off &= ~1;
4069 else
4070 {
4071 bfd_put_32 (output_bfd, relocation,
4072 htab->elf.sgot->contents + off);
4073 h->got.offset |= 1;
4074 }
4075 }
4076 else
4077 unresolved_reloc = FALSE;
4078 }
4079 else
4080 {
4081 if (local_got_offsets == NULL)
4082 abort ();
4083
4084 off = local_got_offsets[r_symndx];
4085
4086 /* The offset must always be a multiple of 4. We use
4087 the least significant bit to record whether we have
4088 already generated the necessary reloc. */
4089 if ((off & 1) != 0)
4090 off &= ~1;
4091 else
4092 {
4093 bfd_put_32 (output_bfd, relocation,
4094 htab->elf.sgot->contents + off);
4095
4096 if (bfd_link_pic (info))
4097 {
4098 asection *s;
4099 Elf_Internal_Rela outrel;
4100
4101 s = htab->elf.srelgot;
4102 if (s == NULL)
4103 abort ();
4104
4105 outrel.r_offset = (htab->elf.sgot->output_section->vma
4106 + htab->elf.sgot->output_offset
4107 + off);
4108 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4109 elf_append_rel (output_bfd, s, &outrel);
4110 }
4111
4112 local_got_offsets[r_symndx] |= 1;
4113 }
4114 }
4115
4116 if (off >= (bfd_vma) -2)
4117 abort ();
4118
4119 relocation = htab->elf.sgot->output_section->vma
4120 + htab->elf.sgot->output_offset + off
4121 - htab->elf.sgotplt->output_section->vma
4122 - htab->elf.sgotplt->output_offset;
4123 break;
4124
4125 case R_386_GOTOFF:
4126 /* Relocation is relative to the start of the global offset
4127 table. */
4128
4129 /* Check to make sure it isn't a protected function or data
4130 symbol for shared library since it may not be local when
4131 used as function address or with copy relocation. We also
4132 need to make sure that a symbol is referenced locally. */
4133 if (!bfd_link_executable (info) && h)
4134 {
4135 if (!h->def_regular)
4136 {
4137 const char *v;
4138
4139 switch (ELF_ST_VISIBILITY (h->other))
4140 {
4141 case STV_HIDDEN:
4142 v = _("hidden symbol");
4143 break;
4144 case STV_INTERNAL:
4145 v = _("internal symbol");
4146 break;
4147 case STV_PROTECTED:
4148 v = _("protected symbol");
4149 break;
4150 default:
4151 v = _("symbol");
4152 break;
4153 }
4154
4155 (*_bfd_error_handler)
4156 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4157 input_bfd, v, h->root.root.string);
4158 bfd_set_error (bfd_error_bad_value);
4159 return FALSE;
4160 }
4161 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4162 && (h->type == STT_FUNC
4163 || h->type == STT_OBJECT)
4164 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4165 {
4166 (*_bfd_error_handler)
4167 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4168 input_bfd,
4169 h->type == STT_FUNC ? "function" : "data",
4170 h->root.root.string);
4171 bfd_set_error (bfd_error_bad_value);
4172 return FALSE;
4173 }
4174 }
4175
4176 /* Note that sgot is not involved in this
4177 calculation. We always want the start of .got.plt. If we
4178 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4179 permitted by the ABI, we might have to change this
4180 calculation. */
4181 relocation -= htab->elf.sgotplt->output_section->vma
4182 + htab->elf.sgotplt->output_offset;
4183 break;
4184
4185 case R_386_GOTPC:
4186 /* Use global offset table as symbol value. */
4187 relocation = htab->elf.sgotplt->output_section->vma
4188 + htab->elf.sgotplt->output_offset;
4189 unresolved_reloc = FALSE;
4190 break;
4191
4192 case R_386_PLT32:
4193 /* Relocation is to the entry for this symbol in the
4194 procedure linkage table. */
4195
4196 /* Resolve a PLT32 reloc against a local symbol directly,
4197 without using the procedure linkage table. */
4198 if (h == NULL)
4199 break;
4200
4201 if ((h->plt.offset == (bfd_vma) -1
4202 && eh->plt_got.offset == (bfd_vma) -1)
4203 || htab->elf.splt == NULL)
4204 {
4205 /* We didn't make a PLT entry for this symbol. This
4206 happens when statically linking PIC code, or when
4207 using -Bsymbolic. */
4208 break;
4209 }
4210
4211 if (h->plt.offset != (bfd_vma) -1)
4212 {
4213 resolved_plt = htab->elf.splt;
4214 plt_offset = h->plt.offset;
4215 }
4216 else
4217 {
4218 resolved_plt = htab->plt_got;
4219 plt_offset = eh->plt_got.offset;
4220 }
4221
4222 relocation = (resolved_plt->output_section->vma
4223 + resolved_plt->output_offset
4224 + plt_offset);
4225 unresolved_reloc = FALSE;
4226 break;
4227
4228 case R_386_SIZE32:
4229 /* Set to symbol size. */
4230 relocation = st_size;
4231 /* Fall through. */
4232
4233 case R_386_32:
4234 case R_386_PC32:
4235 if ((input_section->flags & SEC_ALLOC) == 0
4236 || is_vxworks_tls)
4237 break;
4238
4239 /* Copy dynamic function pointer relocations. */
4240 if ((bfd_link_pic (info)
4241 && (h == NULL
4242 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4243 || h->root.type != bfd_link_hash_undefweak)
4244 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4245 || !SYMBOL_CALLS_LOCAL (info, h)))
4246 || (ELIMINATE_COPY_RELOCS
4247 && !bfd_link_pic (info)
4248 && h != NULL
4249 && h->dynindx != -1
4250 && (!h->non_got_ref || eh->func_pointer_refcount > 0)
4251 && ((h->def_dynamic
4252 && !h->def_regular)
4253 || h->root.type == bfd_link_hash_undefweak
4254 || h->root.type == bfd_link_hash_undefined)))
4255 {
4256 Elf_Internal_Rela outrel;
4257 bfd_boolean skip, relocate;
4258 asection *sreloc;
4259
4260 /* When generating a shared object, these relocations
4261 are copied into the output file to be resolved at run
4262 time. */
4263
4264 skip = FALSE;
4265 relocate = FALSE;
4266
4267 outrel.r_offset =
4268 _bfd_elf_section_offset (output_bfd, info, input_section,
4269 rel->r_offset);
4270 if (outrel.r_offset == (bfd_vma) -1)
4271 skip = TRUE;
4272 else if (outrel.r_offset == (bfd_vma) -2)
4273 skip = TRUE, relocate = TRUE;
4274 outrel.r_offset += (input_section->output_section->vma
4275 + input_section->output_offset);
4276
4277 if (skip)
4278 memset (&outrel, 0, sizeof outrel);
4279 else if (h != NULL
4280 && h->dynindx != -1
4281 && (r_type == R_386_PC32
4282 || !bfd_link_pic (info)
4283 || !SYMBOLIC_BIND (info, h)
4284 || !h->def_regular))
4285 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4286 else
4287 {
4288 /* This symbol is local, or marked to become local. */
4289 relocate = TRUE;
4290 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4291 }
4292
4293 sreloc = elf_section_data (input_section)->sreloc;
4294
4295 if (sreloc == NULL || sreloc->contents == NULL)
4296 {
4297 r = bfd_reloc_notsupported;
4298 goto check_relocation_error;
4299 }
4300
4301 elf_append_rel (output_bfd, sreloc, &outrel);
4302
4303 /* If this reloc is against an external symbol, we do
4304 not want to fiddle with the addend. Otherwise, we
4305 need to include the symbol value so that it becomes
4306 an addend for the dynamic reloc. */
4307 if (! relocate)
4308 continue;
4309 }
4310 break;
4311
4312 case R_386_TLS_IE:
4313 if (!bfd_link_executable (info))
4314 {
4315 Elf_Internal_Rela outrel;
4316 asection *sreloc;
4317
4318 outrel.r_offset = rel->r_offset
4319 + input_section->output_section->vma
4320 + input_section->output_offset;
4321 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4322 sreloc = elf_section_data (input_section)->sreloc;
4323 if (sreloc == NULL)
4324 abort ();
4325 elf_append_rel (output_bfd, sreloc, &outrel);
4326 }
4327 /* Fall through */
4328
4329 case R_386_TLS_GD:
4330 case R_386_TLS_GOTDESC:
4331 case R_386_TLS_DESC_CALL:
4332 case R_386_TLS_IE_32:
4333 case R_386_TLS_GOTIE:
4334 tls_type = GOT_UNKNOWN;
4335 if (h == NULL && local_got_offsets)
4336 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4337 else if (h != NULL)
4338 tls_type = elf_i386_hash_entry(h)->tls_type;
4339 if (tls_type == GOT_TLS_IE)
4340 tls_type = GOT_TLS_IE_NEG;
4341
4342 if (! elf_i386_tls_transition (info, input_bfd,
4343 input_section, contents,
4344 symtab_hdr, sym_hashes,
4345 &r_type, tls_type, rel,
4346 relend, h, r_symndx))
4347 return FALSE;
4348
4349 if (r_type == R_386_TLS_LE_32)
4350 {
4351 BFD_ASSERT (! unresolved_reloc);
4352 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4353 {
4354 unsigned int type;
4355 bfd_vma roff;
4356
4357 /* GD->LE transition. */
4358 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4359 if (type == 0x04)
4360 {
4361 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4362 Change it into:
4363 movl %gs:0, %eax; subl $foo@tpoff, %eax
4364 (6 byte form of subl). */
4365 memcpy (contents + rel->r_offset - 3,
4366 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4367 roff = rel->r_offset + 5;
4368 }
4369 else
4370 {
4371 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4372 Change it into:
4373 movl %gs:0, %eax; subl $foo@tpoff, %eax
4374 (6 byte form of subl). */
4375 memcpy (contents + rel->r_offset - 2,
4376 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4377 roff = rel->r_offset + 6;
4378 }
4379 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4380 contents + roff);
4381 /* Skip R_386_PC32/R_386_PLT32. */
4382 rel++;
4383 wrel++;
4384 continue;
4385 }
4386 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4387 {
4388 /* GDesc -> LE transition.
4389 It's originally something like:
4390 leal x@tlsdesc(%ebx), %eax
4391
4392 leal x@ntpoff, %eax
4393
4394 Registers other than %eax may be set up here. */
4395
4396 unsigned int val;
4397 bfd_vma roff;
4398
4399 roff = rel->r_offset;
4400 val = bfd_get_8 (input_bfd, contents + roff - 1);
4401
4402 /* Now modify the instruction as appropriate. */
4403 /* aoliva FIXME: remove the above and xor the byte
4404 below with 0x86. */
4405 bfd_put_8 (output_bfd, val ^ 0x86,
4406 contents + roff - 1);
4407 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4408 contents + roff);
4409 continue;
4410 }
4411 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4412 {
4413 /* GDesc -> LE transition.
4414 It's originally:
4415 call *(%eax)
4416 Turn it into:
4417 xchg %ax,%ax */
4418
4419 bfd_vma roff;
4420
4421 roff = rel->r_offset;
4422 bfd_put_8 (output_bfd, 0x66, contents + roff);
4423 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4424 continue;
4425 }
4426 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4427 {
4428 unsigned int val;
4429
4430 /* IE->LE transition:
4431 Originally it can be one of:
4432 movl foo, %eax
4433 movl foo, %reg
4434 addl foo, %reg
4435 We change it into:
4436 movl $foo, %eax
4437 movl $foo, %reg
4438 addl $foo, %reg. */
4439 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4440 if (val == 0xa1)
4441 {
4442 /* movl foo, %eax. */
4443 bfd_put_8 (output_bfd, 0xb8,
4444 contents + rel->r_offset - 1);
4445 }
4446 else
4447 {
4448 unsigned int type;
4449
4450 type = bfd_get_8 (input_bfd,
4451 contents + rel->r_offset - 2);
4452 switch (type)
4453 {
4454 case 0x8b:
4455 /* movl */
4456 bfd_put_8 (output_bfd, 0xc7,
4457 contents + rel->r_offset - 2);
4458 bfd_put_8 (output_bfd,
4459 0xc0 | ((val >> 3) & 7),
4460 contents + rel->r_offset - 1);
4461 break;
4462 case 0x03:
4463 /* addl */
4464 bfd_put_8 (output_bfd, 0x81,
4465 contents + rel->r_offset - 2);
4466 bfd_put_8 (output_bfd,
4467 0xc0 | ((val >> 3) & 7),
4468 contents + rel->r_offset - 1);
4469 break;
4470 default:
4471 BFD_FAIL ();
4472 break;
4473 }
4474 }
4475 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4476 contents + rel->r_offset);
4477 continue;
4478 }
4479 else
4480 {
4481 unsigned int val, type;
4482
4483 /* {IE_32,GOTIE}->LE transition:
4484 Originally it can be one of:
4485 subl foo(%reg1), %reg2
4486 movl foo(%reg1), %reg2
4487 addl foo(%reg1), %reg2
4488 We change it into:
4489 subl $foo, %reg2
4490 movl $foo, %reg2 (6 byte form)
4491 addl $foo, %reg2. */
4492 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4493 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4494 if (type == 0x8b)
4495 {
4496 /* movl */
4497 bfd_put_8 (output_bfd, 0xc7,
4498 contents + rel->r_offset - 2);
4499 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4500 contents + rel->r_offset - 1);
4501 }
4502 else if (type == 0x2b)
4503 {
4504 /* subl */
4505 bfd_put_8 (output_bfd, 0x81,
4506 contents + rel->r_offset - 2);
4507 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4508 contents + rel->r_offset - 1);
4509 }
4510 else if (type == 0x03)
4511 {
4512 /* addl */
4513 bfd_put_8 (output_bfd, 0x81,
4514 contents + rel->r_offset - 2);
4515 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4516 contents + rel->r_offset - 1);
4517 }
4518 else
4519 BFD_FAIL ();
4520 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4521 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4522 contents + rel->r_offset);
4523 else
4524 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4525 contents + rel->r_offset);
4526 continue;
4527 }
4528 }
4529
4530 if (htab->elf.sgot == NULL)
4531 abort ();
4532
4533 if (h != NULL)
4534 {
4535 off = h->got.offset;
4536 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4537 }
4538 else
4539 {
4540 if (local_got_offsets == NULL)
4541 abort ();
4542
4543 off = local_got_offsets[r_symndx];
4544 offplt = local_tlsdesc_gotents[r_symndx];
4545 }
4546
4547 if ((off & 1) != 0)
4548 off &= ~1;
4549 else
4550 {
4551 Elf_Internal_Rela outrel;
4552 int dr_type;
4553 asection *sreloc;
4554
4555 if (htab->elf.srelgot == NULL)
4556 abort ();
4557
4558 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4559
4560 if (GOT_TLS_GDESC_P (tls_type))
4561 {
4562 bfd_byte *loc;
4563 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4564 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4565 <= htab->elf.sgotplt->size);
4566 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4567 + htab->elf.sgotplt->output_offset
4568 + offplt
4569 + htab->sgotplt_jump_table_size);
4570 sreloc = htab->elf.srelplt;
4571 loc = sreloc->contents;
4572 loc += (htab->next_tls_desc_index++
4573 * sizeof (Elf32_External_Rel));
4574 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4575 <= sreloc->contents + sreloc->size);
4576 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4577 if (indx == 0)
4578 {
4579 BFD_ASSERT (! unresolved_reloc);
4580 bfd_put_32 (output_bfd,
4581 relocation - elf_i386_dtpoff_base (info),
4582 htab->elf.sgotplt->contents + offplt
4583 + htab->sgotplt_jump_table_size + 4);
4584 }
4585 else
4586 {
4587 bfd_put_32 (output_bfd, 0,
4588 htab->elf.sgotplt->contents + offplt
4589 + htab->sgotplt_jump_table_size + 4);
4590 }
4591 }
4592
4593 sreloc = htab->elf.srelgot;
4594
4595 outrel.r_offset = (htab->elf.sgot->output_section->vma
4596 + htab->elf.sgot->output_offset + off);
4597
4598 if (GOT_TLS_GD_P (tls_type))
4599 dr_type = R_386_TLS_DTPMOD32;
4600 else if (GOT_TLS_GDESC_P (tls_type))
4601 goto dr_done;
4602 else if (tls_type == GOT_TLS_IE_POS)
4603 dr_type = R_386_TLS_TPOFF;
4604 else
4605 dr_type = R_386_TLS_TPOFF32;
4606
4607 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4608 bfd_put_32 (output_bfd,
4609 relocation - elf_i386_dtpoff_base (info),
4610 htab->elf.sgot->contents + off);
4611 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4612 bfd_put_32 (output_bfd,
4613 elf_i386_dtpoff_base (info) - relocation,
4614 htab->elf.sgot->contents + off);
4615 else if (dr_type != R_386_TLS_DESC)
4616 bfd_put_32 (output_bfd, 0,
4617 htab->elf.sgot->contents + off);
4618 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4619
4620 elf_append_rel (output_bfd, sreloc, &outrel);
4621
4622 if (GOT_TLS_GD_P (tls_type))
4623 {
4624 if (indx == 0)
4625 {
4626 BFD_ASSERT (! unresolved_reloc);
4627 bfd_put_32 (output_bfd,
4628 relocation - elf_i386_dtpoff_base (info),
4629 htab->elf.sgot->contents + off + 4);
4630 }
4631 else
4632 {
4633 bfd_put_32 (output_bfd, 0,
4634 htab->elf.sgot->contents + off + 4);
4635 outrel.r_info = ELF32_R_INFO (indx,
4636 R_386_TLS_DTPOFF32);
4637 outrel.r_offset += 4;
4638 elf_append_rel (output_bfd, sreloc, &outrel);
4639 }
4640 }
4641 else if (tls_type == GOT_TLS_IE_BOTH)
4642 {
4643 bfd_put_32 (output_bfd,
4644 (indx == 0
4645 ? relocation - elf_i386_dtpoff_base (info)
4646 : 0),
4647 htab->elf.sgot->contents + off + 4);
4648 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4649 outrel.r_offset += 4;
4650 elf_append_rel (output_bfd, sreloc, &outrel);
4651 }
4652
4653 dr_done:
4654 if (h != NULL)
4655 h->got.offset |= 1;
4656 else
4657 local_got_offsets[r_symndx] |= 1;
4658 }
4659
4660 if (off >= (bfd_vma) -2
4661 && ! GOT_TLS_GDESC_P (tls_type))
4662 abort ();
4663 if (r_type == R_386_TLS_GOTDESC
4664 || r_type == R_386_TLS_DESC_CALL)
4665 {
4666 relocation = htab->sgotplt_jump_table_size + offplt;
4667 unresolved_reloc = FALSE;
4668 }
4669 else if (r_type == ELF32_R_TYPE (rel->r_info))
4670 {
4671 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4672 + htab->elf.sgotplt->output_offset;
4673 relocation = htab->elf.sgot->output_section->vma
4674 + htab->elf.sgot->output_offset + off - g_o_t;
4675 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4676 && tls_type == GOT_TLS_IE_BOTH)
4677 relocation += 4;
4678 if (r_type == R_386_TLS_IE)
4679 relocation += g_o_t;
4680 unresolved_reloc = FALSE;
4681 }
4682 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4683 {
4684 unsigned int val, type;
4685 bfd_vma roff;
4686
4687 /* GD->IE transition. */
4688 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4689 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4690 if (type == 0x04)
4691 {
4692 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4693 Change it into:
4694 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4695 val >>= 3;
4696 roff = rel->r_offset - 3;
4697 }
4698 else
4699 {
4700 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4701 Change it into:
4702 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4703 roff = rel->r_offset - 2;
4704 }
4705 memcpy (contents + roff,
4706 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4707 contents[roff + 7] = 0x80 | (val & 7);
4708 /* If foo is used only with foo@gotntpoff(%reg) and
4709 foo@indntpoff, but not with foo@gottpoff(%reg), change
4710 subl $foo@gottpoff(%reg), %eax
4711 into:
4712 addl $foo@gotntpoff(%reg), %eax. */
4713 if (tls_type == GOT_TLS_IE_POS)
4714 contents[roff + 6] = 0x03;
4715 bfd_put_32 (output_bfd,
4716 htab->elf.sgot->output_section->vma
4717 + htab->elf.sgot->output_offset + off
4718 - htab->elf.sgotplt->output_section->vma
4719 - htab->elf.sgotplt->output_offset,
4720 contents + roff + 8);
4721 /* Skip R_386_PLT32. */
4722 rel++;
4723 wrel++;
4724 continue;
4725 }
4726 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4727 {
4728 /* GDesc -> IE transition.
4729 It's originally something like:
4730 leal x@tlsdesc(%ebx), %eax
4731
4732 Change it to:
4733 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4734 or:
4735 movl x@gottpoff(%ebx), %eax # before negl %eax
4736
4737 Registers other than %eax may be set up here. */
4738
4739 bfd_vma roff;
4740
4741 /* First, make sure it's a leal adding ebx to a 32-bit
4742 offset into any register, although it's probably
4743 almost always going to be eax. */
4744 roff = rel->r_offset;
4745
4746 /* Now modify the instruction as appropriate. */
4747 /* To turn a leal into a movl in the form we use it, it
4748 suffices to change the first byte from 0x8d to 0x8b.
4749 aoliva FIXME: should we decide to keep the leal, all
4750 we have to do is remove the statement below, and
4751 adjust the relaxation of R_386_TLS_DESC_CALL. */
4752 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4753
4754 if (tls_type == GOT_TLS_IE_BOTH)
4755 off += 4;
4756
4757 bfd_put_32 (output_bfd,
4758 htab->elf.sgot->output_section->vma
4759 + htab->elf.sgot->output_offset + off
4760 - htab->elf.sgotplt->output_section->vma
4761 - htab->elf.sgotplt->output_offset,
4762 contents + roff);
4763 continue;
4764 }
4765 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4766 {
4767 /* GDesc -> IE transition.
4768 It's originally:
4769 call *(%eax)
4770
4771 Change it to:
4772 xchg %ax,%ax
4773 or
4774 negl %eax
4775 depending on how we transformed the TLS_GOTDESC above.
4776 */
4777
4778 bfd_vma roff;
4779
4780 roff = rel->r_offset;
4781
4782 /* Now modify the instruction as appropriate. */
4783 if (tls_type != GOT_TLS_IE_NEG)
4784 {
4785 /* xchg %ax,%ax */
4786 bfd_put_8 (output_bfd, 0x66, contents + roff);
4787 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4788 }
4789 else
4790 {
4791 /* negl %eax */
4792 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4793 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4794 }
4795
4796 continue;
4797 }
4798 else
4799 BFD_ASSERT (FALSE);
4800 break;
4801
4802 case R_386_TLS_LDM:
4803 if (! elf_i386_tls_transition (info, input_bfd,
4804 input_section, contents,
4805 symtab_hdr, sym_hashes,
4806 &r_type, GOT_UNKNOWN, rel,
4807 relend, h, r_symndx))
4808 return FALSE;
4809
4810 if (r_type != R_386_TLS_LDM)
4811 {
4812 /* LD->LE transition:
4813 leal foo(%reg), %eax; call ___tls_get_addr.
4814 We change it into:
4815 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4816 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4817 memcpy (contents + rel->r_offset - 2,
4818 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4819 /* Skip R_386_PC32/R_386_PLT32. */
4820 rel++;
4821 wrel++;
4822 continue;
4823 }
4824
4825 if (htab->elf.sgot == NULL)
4826 abort ();
4827
4828 off = htab->tls_ldm_got.offset;
4829 if (off & 1)
4830 off &= ~1;
4831 else
4832 {
4833 Elf_Internal_Rela outrel;
4834
4835 if (htab->elf.srelgot == NULL)
4836 abort ();
4837
4838 outrel.r_offset = (htab->elf.sgot->output_section->vma
4839 + htab->elf.sgot->output_offset + off);
4840
4841 bfd_put_32 (output_bfd, 0,
4842 htab->elf.sgot->contents + off);
4843 bfd_put_32 (output_bfd, 0,
4844 htab->elf.sgot->contents + off + 4);
4845 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4846 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4847 htab->tls_ldm_got.offset |= 1;
4848 }
4849 relocation = htab->elf.sgot->output_section->vma
4850 + htab->elf.sgot->output_offset + off
4851 - htab->elf.sgotplt->output_section->vma
4852 - htab->elf.sgotplt->output_offset;
4853 unresolved_reloc = FALSE;
4854 break;
4855
4856 case R_386_TLS_LDO_32:
4857 if (!bfd_link_executable (info)
4858 || (input_section->flags & SEC_CODE) == 0)
4859 relocation -= elf_i386_dtpoff_base (info);
4860 else
4861 /* When converting LDO to LE, we must negate. */
4862 relocation = -elf_i386_tpoff (info, relocation);
4863 break;
4864
4865 case R_386_TLS_LE_32:
4866 case R_386_TLS_LE:
4867 if (!bfd_link_executable (info))
4868 {
4869 Elf_Internal_Rela outrel;
4870 asection *sreloc;
4871
4872 outrel.r_offset = rel->r_offset
4873 + input_section->output_section->vma
4874 + input_section->output_offset;
4875 if (h != NULL && h->dynindx != -1)
4876 indx = h->dynindx;
4877 else
4878 indx = 0;
4879 if (r_type == R_386_TLS_LE_32)
4880 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4881 else
4882 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4883 sreloc = elf_section_data (input_section)->sreloc;
4884 if (sreloc == NULL)
4885 abort ();
4886 elf_append_rel (output_bfd, sreloc, &outrel);
4887 if (indx)
4888 continue;
4889 else if (r_type == R_386_TLS_LE_32)
4890 relocation = elf_i386_dtpoff_base (info) - relocation;
4891 else
4892 relocation -= elf_i386_dtpoff_base (info);
4893 }
4894 else if (r_type == R_386_TLS_LE_32)
4895 relocation = elf_i386_tpoff (info, relocation);
4896 else
4897 relocation = -elf_i386_tpoff (info, relocation);
4898 break;
4899
4900 default:
4901 break;
4902 }
4903
4904 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4905 because such sections are not SEC_ALLOC and thus ld.so will
4906 not process them. */
4907 if (unresolved_reloc
4908 && !((input_section->flags & SEC_DEBUGGING) != 0
4909 && h->def_dynamic)
4910 && _bfd_elf_section_offset (output_bfd, info, input_section,
4911 rel->r_offset) != (bfd_vma) -1)
4912 {
4913 (*_bfd_error_handler)
4914 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4915 input_bfd,
4916 input_section,
4917 (long) rel->r_offset,
4918 howto->name,
4919 h->root.root.string);
4920 return FALSE;
4921 }
4922
4923 do_relocation:
4924 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4925 contents, rel->r_offset,
4926 relocation, 0);
4927
4928 check_relocation_error:
4929 if (r != bfd_reloc_ok)
4930 {
4931 const char *name;
4932
4933 if (h != NULL)
4934 name = h->root.root.string;
4935 else
4936 {
4937 name = bfd_elf_string_from_elf_section (input_bfd,
4938 symtab_hdr->sh_link,
4939 sym->st_name);
4940 if (name == NULL)
4941 return FALSE;
4942 if (*name == '\0')
4943 name = bfd_section_name (input_bfd, sec);
4944 }
4945
4946 if (r == bfd_reloc_overflow)
4947 {
4948 if (! ((*info->callbacks->reloc_overflow)
4949 (info, (h ? &h->root : NULL), name, howto->name,
4950 (bfd_vma) 0, input_bfd, input_section,
4951 rel->r_offset)))
4952 return FALSE;
4953 }
4954 else
4955 {
4956 (*_bfd_error_handler)
4957 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4958 input_bfd, input_section,
4959 (long) rel->r_offset, name, (int) r);
4960 return FALSE;
4961 }
4962 }
4963
4964 if (wrel != rel)
4965 *wrel = *rel;
4966 }
4967
4968 if (wrel != rel)
4969 {
4970 Elf_Internal_Shdr *rel_hdr;
4971 size_t deleted = rel - wrel;
4972
4973 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
4974 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4975 if (rel_hdr->sh_size == 0)
4976 {
4977 /* It is too late to remove an empty reloc section. Leave
4978 one NONE reloc.
4979 ??? What is wrong with an empty section??? */
4980 rel_hdr->sh_size = rel_hdr->sh_entsize;
4981 deleted -= 1;
4982 }
4983 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
4984 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4985 input_section->reloc_count -= deleted;
4986 }
4987
4988 return TRUE;
4989 }
4990
4991 /* Finish up dynamic symbol handling. We set the contents of various
4992 dynamic sections here. */
4993
4994 static bfd_boolean
4995 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4996 struct bfd_link_info *info,
4997 struct elf_link_hash_entry *h,
4998 Elf_Internal_Sym *sym)
4999 {
5000 struct elf_i386_link_hash_table *htab;
5001 unsigned plt_entry_size;
5002 const struct elf_i386_backend_data *abed;
5003 struct elf_i386_link_hash_entry *eh;
5004
5005 htab = elf_i386_hash_table (info);
5006 if (htab == NULL)
5007 return FALSE;
5008
5009 abed = get_elf_i386_backend_data (output_bfd);
5010 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5011
5012 eh = (struct elf_i386_link_hash_entry *) h;
5013
5014 if (h->plt.offset != (bfd_vma) -1)
5015 {
5016 bfd_vma plt_index;
5017 bfd_vma got_offset;
5018 Elf_Internal_Rela rel;
5019 bfd_byte *loc;
5020 asection *plt, *gotplt, *relplt;
5021
5022 /* When building a static executable, use .iplt, .igot.plt and
5023 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5024 if (htab->elf.splt != NULL)
5025 {
5026 plt = htab->elf.splt;
5027 gotplt = htab->elf.sgotplt;
5028 relplt = htab->elf.srelplt;
5029 }
5030 else
5031 {
5032 plt = htab->elf.iplt;
5033 gotplt = htab->elf.igotplt;
5034 relplt = htab->elf.irelplt;
5035 }
5036
5037 /* This symbol has an entry in the procedure linkage table. Set
5038 it up. */
5039
5040 if ((h->dynindx == -1
5041 && !((h->forced_local || bfd_link_executable (info))
5042 && h->def_regular
5043 && h->type == STT_GNU_IFUNC))
5044 || plt == NULL
5045 || gotplt == NULL
5046 || relplt == NULL)
5047 abort ();
5048
5049 /* Get the index in the procedure linkage table which
5050 corresponds to this symbol. This is the index of this symbol
5051 in all the symbols for which we are making plt entries. The
5052 first entry in the procedure linkage table is reserved.
5053
5054 Get the offset into the .got table of the entry that
5055 corresponds to this function. Each .got entry is 4 bytes.
5056 The first three are reserved.
5057
5058 For static executables, we don't reserve anything. */
5059
5060 if (plt == htab->elf.splt)
5061 {
5062 got_offset = h->plt.offset / plt_entry_size - 1;
5063 got_offset = (got_offset + 3) * 4;
5064 }
5065 else
5066 {
5067 got_offset = h->plt.offset / plt_entry_size;
5068 got_offset = got_offset * 4;
5069 }
5070
5071 /* Fill in the entry in the procedure linkage table. */
5072 if (! bfd_link_pic (info))
5073 {
5074 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5075 abed->plt->plt_entry_size);
5076 bfd_put_32 (output_bfd,
5077 (gotplt->output_section->vma
5078 + gotplt->output_offset
5079 + got_offset),
5080 plt->contents + h->plt.offset
5081 + abed->plt->plt_got_offset);
5082
5083 if (abed->is_vxworks)
5084 {
5085 int s, k, reloc_index;
5086
5087 /* Create the R_386_32 relocation referencing the GOT
5088 for this PLT entry. */
5089
5090 /* S: Current slot number (zero-based). */
5091 s = ((h->plt.offset - abed->plt->plt_entry_size)
5092 / abed->plt->plt_entry_size);
5093 /* K: Number of relocations for PLTResolve. */
5094 if (bfd_link_pic (info))
5095 k = PLTRESOLVE_RELOCS_SHLIB;
5096 else
5097 k = PLTRESOLVE_RELOCS;
5098 /* Skip the PLTresolve relocations, and the relocations for
5099 the other PLT slots. */
5100 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5101 loc = (htab->srelplt2->contents + reloc_index
5102 * sizeof (Elf32_External_Rel));
5103
5104 rel.r_offset = (htab->elf.splt->output_section->vma
5105 + htab->elf.splt->output_offset
5106 + h->plt.offset + 2),
5107 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5108 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5109
5110 /* Create the R_386_32 relocation referencing the beginning of
5111 the PLT for this GOT entry. */
5112 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5113 + htab->elf.sgotplt->output_offset
5114 + got_offset);
5115 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5116 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5117 loc + sizeof (Elf32_External_Rel));
5118 }
5119 }
5120 else
5121 {
5122 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5123 abed->plt->plt_entry_size);
5124 bfd_put_32 (output_bfd, got_offset,
5125 plt->contents + h->plt.offset
5126 + abed->plt->plt_got_offset);
5127 }
5128
5129 /* Fill in the entry in the global offset table. */
5130 bfd_put_32 (output_bfd,
5131 (plt->output_section->vma
5132 + plt->output_offset
5133 + h->plt.offset
5134 + abed->plt->plt_lazy_offset),
5135 gotplt->contents + got_offset);
5136
5137 /* Fill in the entry in the .rel.plt section. */
5138 rel.r_offset = (gotplt->output_section->vma
5139 + gotplt->output_offset
5140 + got_offset);
5141 if (h->dynindx == -1
5142 || ((bfd_link_executable (info)
5143 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5144 && h->def_regular
5145 && h->type == STT_GNU_IFUNC))
5146 {
5147 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5148 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5149 in the .got.plt section. */
5150 bfd_put_32 (output_bfd,
5151 (h->root.u.def.value
5152 + h->root.u.def.section->output_section->vma
5153 + h->root.u.def.section->output_offset),
5154 gotplt->contents + got_offset);
5155 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5156 /* R_386_IRELATIVE comes last. */
5157 plt_index = htab->next_irelative_index--;
5158 }
5159 else
5160 {
5161 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5162 plt_index = htab->next_jump_slot_index++;
5163 }
5164 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5165 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5166
5167 /* Don't fill PLT entry for static executables. */
5168 if (plt == htab->elf.splt)
5169 {
5170 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
5171 plt->contents + h->plt.offset
5172 + abed->plt->plt_reloc_offset);
5173 bfd_put_32 (output_bfd, - (h->plt.offset
5174 + abed->plt->plt_plt_offset + 4),
5175 plt->contents + h->plt.offset
5176 + abed->plt->plt_plt_offset);
5177 }
5178 }
5179 else if (eh->plt_got.offset != (bfd_vma) -1)
5180 {
5181 bfd_vma got_offset, plt_offset;
5182 asection *plt, *got, *gotplt;
5183 const bfd_byte *got_plt_entry;
5184
5185 /* Offset of displacement of the indirect jump. */
5186 bfd_vma plt_got_offset = 2;
5187
5188 /* Set the entry in the GOT procedure linkage table. */
5189 plt = htab->plt_got;
5190 got = htab->elf.sgot;
5191 gotplt = htab->elf.sgotplt;
5192 got_offset = h->got.offset;
5193
5194 if (got_offset == (bfd_vma) -1
5195 || plt == NULL
5196 || got == NULL
5197 || gotplt == NULL)
5198 abort ();
5199
5200 /* Fill in the entry in the GOT procedure linkage table. */
5201 if (! bfd_link_pic (info))
5202 {
5203 got_plt_entry = elf_i386_got_plt_entry;
5204 got_offset += got->output_section->vma + got->output_offset;
5205 }
5206 else
5207 {
5208 got_plt_entry = elf_i386_pic_got_plt_entry;
5209 got_offset += (got->output_section->vma
5210 + got->output_offset
5211 - gotplt->output_section->vma
5212 - gotplt->output_offset);
5213 }
5214
5215 plt_offset = eh->plt_got.offset;
5216 memcpy (plt->contents + plt_offset, got_plt_entry,
5217 sizeof (elf_i386_got_plt_entry));
5218 bfd_put_32 (output_bfd, got_offset,
5219 plt->contents + plt_offset + plt_got_offset);
5220 }
5221
5222 if (!h->def_regular
5223 && (h->plt.offset != (bfd_vma) -1
5224 || eh->plt_got.offset != (bfd_vma) -1))
5225 {
5226 /* Mark the symbol as undefined, rather than as defined in
5227 the .plt section. Leave the value if there were any
5228 relocations where pointer equality matters (this is a clue
5229 for the dynamic linker, to make function pointer
5230 comparisons work between an application and shared
5231 library), otherwise set it to zero. If a function is only
5232 called from a binary, there is no need to slow down
5233 shared libraries because of that. */
5234 sym->st_shndx = SHN_UNDEF;
5235 if (!h->pointer_equality_needed)
5236 sym->st_value = 0;
5237 }
5238
5239 if (h->got.offset != (bfd_vma) -1
5240 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5241 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
5242 {
5243 Elf_Internal_Rela rel;
5244
5245 /* This symbol has an entry in the global offset table. Set it
5246 up. */
5247
5248 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5249 abort ();
5250
5251 rel.r_offset = (htab->elf.sgot->output_section->vma
5252 + htab->elf.sgot->output_offset
5253 + (h->got.offset & ~(bfd_vma) 1));
5254
5255 /* If this is a static link, or it is a -Bsymbolic link and the
5256 symbol is defined locally or was forced to be local because
5257 of a version file, we just want to emit a RELATIVE reloc.
5258 The entry in the global offset table will already have been
5259 initialized in the relocate_section function. */
5260 if (h->def_regular
5261 && h->type == STT_GNU_IFUNC)
5262 {
5263 if (bfd_link_pic (info))
5264 {
5265 /* Generate R_386_GLOB_DAT. */
5266 goto do_glob_dat;
5267 }
5268 else
5269 {
5270 asection *plt;
5271
5272 if (!h->pointer_equality_needed)
5273 abort ();
5274
5275 /* For non-shared object, we can't use .got.plt, which
5276 contains the real function addres if we need pointer
5277 equality. We load the GOT entry with the PLT entry. */
5278 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5279 bfd_put_32 (output_bfd,
5280 (plt->output_section->vma
5281 + plt->output_offset + h->plt.offset),
5282 htab->elf.sgot->contents + h->got.offset);
5283 return TRUE;
5284 }
5285 }
5286 else if (bfd_link_pic (info)
5287 && SYMBOL_REFERENCES_LOCAL (info, h))
5288 {
5289 BFD_ASSERT((h->got.offset & 1) != 0);
5290 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5291 }
5292 else
5293 {
5294 BFD_ASSERT((h->got.offset & 1) == 0);
5295 do_glob_dat:
5296 bfd_put_32 (output_bfd, (bfd_vma) 0,
5297 htab->elf.sgot->contents + h->got.offset);
5298 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5299 }
5300
5301 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
5302 }
5303
5304 if (h->needs_copy)
5305 {
5306 Elf_Internal_Rela rel;
5307
5308 /* This symbol needs a copy reloc. Set it up. */
5309
5310 if (h->dynindx == -1
5311 || (h->root.type != bfd_link_hash_defined
5312 && h->root.type != bfd_link_hash_defweak)
5313 || htab->srelbss == NULL)
5314 abort ();
5315
5316 rel.r_offset = (h->root.u.def.value
5317 + h->root.u.def.section->output_section->vma
5318 + h->root.u.def.section->output_offset);
5319 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5320 elf_append_rel (output_bfd, htab->srelbss, &rel);
5321 }
5322
5323 return TRUE;
5324 }
5325
5326 /* Finish up local dynamic symbol handling. We set the contents of
5327 various dynamic sections here. */
5328
5329 static bfd_boolean
5330 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5331 {
5332 struct elf_link_hash_entry *h
5333 = (struct elf_link_hash_entry *) *slot;
5334 struct bfd_link_info *info
5335 = (struct bfd_link_info *) inf;
5336
5337 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5338 h, NULL);
5339 }
5340
5341 /* Used to decide how to sort relocs in an optimal manner for the
5342 dynamic linker, before writing them out. */
5343
5344 static enum elf_reloc_type_class
5345 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5346 const asection *rel_sec ATTRIBUTE_UNUSED,
5347 const Elf_Internal_Rela *rela)
5348 {
5349 bfd *abfd = info->output_bfd;
5350 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5351 struct elf_link_hash_table *htab = elf_hash_table (info);
5352 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5353 Elf_Internal_Sym sym;
5354
5355 if (htab->dynsym == NULL
5356 || !bed->s->swap_symbol_in (abfd,
5357 (htab->dynsym->contents
5358 + r_symndx * sizeof (Elf32_External_Sym)),
5359 0, &sym))
5360 abort ();
5361
5362 /* Check relocation against STT_GNU_IFUNC symbol. */
5363 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5364 return reloc_class_ifunc;
5365
5366 switch (ELF32_R_TYPE (rela->r_info))
5367 {
5368 case R_386_RELATIVE:
5369 return reloc_class_relative;
5370 case R_386_JUMP_SLOT:
5371 return reloc_class_plt;
5372 case R_386_COPY:
5373 return reloc_class_copy;
5374 default:
5375 return reloc_class_normal;
5376 }
5377 }
5378
5379 /* Finish up the dynamic sections. */
5380
5381 static bfd_boolean
5382 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5383 struct bfd_link_info *info)
5384 {
5385 struct elf_i386_link_hash_table *htab;
5386 bfd *dynobj;
5387 asection *sdyn;
5388 const struct elf_i386_backend_data *abed;
5389
5390 htab = elf_i386_hash_table (info);
5391 if (htab == NULL)
5392 return FALSE;
5393
5394 dynobj = htab->elf.dynobj;
5395 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5396 abed = get_elf_i386_backend_data (output_bfd);
5397
5398 if (htab->elf.dynamic_sections_created)
5399 {
5400 Elf32_External_Dyn *dyncon, *dynconend;
5401
5402 if (sdyn == NULL || htab->elf.sgot == NULL)
5403 abort ();
5404
5405 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5406 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5407 for (; dyncon < dynconend; dyncon++)
5408 {
5409 Elf_Internal_Dyn dyn;
5410 asection *s;
5411
5412 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5413
5414 switch (dyn.d_tag)
5415 {
5416 default:
5417 if (abed->is_vxworks
5418 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5419 break;
5420 continue;
5421
5422 case DT_PLTGOT:
5423 s = htab->elf.sgotplt;
5424 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5425 break;
5426
5427 case DT_JMPREL:
5428 s = htab->elf.srelplt;
5429 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5430 break;
5431
5432 case DT_PLTRELSZ:
5433 s = htab->elf.srelplt;
5434 dyn.d_un.d_val = s->size;
5435 break;
5436
5437 case DT_RELSZ:
5438 /* My reading of the SVR4 ABI indicates that the
5439 procedure linkage table relocs (DT_JMPREL) should be
5440 included in the overall relocs (DT_REL). This is
5441 what Solaris does. However, UnixWare can not handle
5442 that case. Therefore, we override the DT_RELSZ entry
5443 here to make it not include the JMPREL relocs. */
5444 s = htab->elf.srelplt;
5445 if (s == NULL)
5446 continue;
5447 dyn.d_un.d_val -= s->size;
5448 break;
5449
5450 case DT_REL:
5451 /* We may not be using the standard ELF linker script.
5452 If .rel.plt is the first .rel section, we adjust
5453 DT_REL to not include it. */
5454 s = htab->elf.srelplt;
5455 if (s == NULL)
5456 continue;
5457 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5458 continue;
5459 dyn.d_un.d_ptr += s->size;
5460 break;
5461 }
5462
5463 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5464 }
5465
5466 /* Fill in the first entry in the procedure linkage table. */
5467 if (htab->elf.splt && htab->elf.splt->size > 0)
5468 {
5469 if (bfd_link_pic (info))
5470 {
5471 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5472 abed->plt->plt0_entry_size);
5473 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5474 abed->plt0_pad_byte,
5475 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5476 }
5477 else
5478 {
5479 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5480 abed->plt->plt0_entry_size);
5481 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5482 abed->plt0_pad_byte,
5483 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5484 bfd_put_32 (output_bfd,
5485 (htab->elf.sgotplt->output_section->vma
5486 + htab->elf.sgotplt->output_offset
5487 + 4),
5488 htab->elf.splt->contents
5489 + abed->plt->plt0_got1_offset);
5490 bfd_put_32 (output_bfd,
5491 (htab->elf.sgotplt->output_section->vma
5492 + htab->elf.sgotplt->output_offset
5493 + 8),
5494 htab->elf.splt->contents
5495 + abed->plt->plt0_got2_offset);
5496
5497 if (abed->is_vxworks)
5498 {
5499 Elf_Internal_Rela rel;
5500
5501 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5502 On IA32 we use REL relocations so the addend goes in
5503 the PLT directly. */
5504 rel.r_offset = (htab->elf.splt->output_section->vma
5505 + htab->elf.splt->output_offset
5506 + abed->plt->plt0_got1_offset);
5507 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5508 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5509 htab->srelplt2->contents);
5510 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5511 rel.r_offset = (htab->elf.splt->output_section->vma
5512 + htab->elf.splt->output_offset
5513 + abed->plt->plt0_got2_offset);
5514 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5515 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5516 htab->srelplt2->contents +
5517 sizeof (Elf32_External_Rel));
5518 }
5519 }
5520
5521 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5522 really seem like the right value. */
5523 elf_section_data (htab->elf.splt->output_section)
5524 ->this_hdr.sh_entsize = 4;
5525
5526 /* Correct the .rel.plt.unloaded relocations. */
5527 if (abed->is_vxworks && !bfd_link_pic (info))
5528 {
5529 int num_plts = (htab->elf.splt->size
5530 / abed->plt->plt_entry_size) - 1;
5531 unsigned char *p;
5532
5533 p = htab->srelplt2->contents;
5534 if (bfd_link_pic (info))
5535 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5536 else
5537 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5538
5539 for (; num_plts; num_plts--)
5540 {
5541 Elf_Internal_Rela rel;
5542 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5543 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5544 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5545 p += sizeof (Elf32_External_Rel);
5546
5547 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5548 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5549 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5550 p += sizeof (Elf32_External_Rel);
5551 }
5552 }
5553 }
5554 }
5555
5556 if (htab->elf.sgotplt)
5557 {
5558 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5559 {
5560 (*_bfd_error_handler)
5561 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5562 return FALSE;
5563 }
5564
5565 /* Fill in the first three entries in the global offset table. */
5566 if (htab->elf.sgotplt->size > 0)
5567 {
5568 bfd_put_32 (output_bfd,
5569 (sdyn == NULL ? 0
5570 : sdyn->output_section->vma + sdyn->output_offset),
5571 htab->elf.sgotplt->contents);
5572 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5573 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5574 }
5575
5576 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5577 }
5578
5579 /* Adjust .eh_frame for .plt section. */
5580 if (htab->plt_eh_frame != NULL
5581 && htab->plt_eh_frame->contents != NULL)
5582 {
5583 if (htab->elf.splt != NULL
5584 && htab->elf.splt->size != 0
5585 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5586 && htab->elf.splt->output_section != NULL
5587 && htab->plt_eh_frame->output_section != NULL)
5588 {
5589 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5590 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5591 + htab->plt_eh_frame->output_offset
5592 + PLT_FDE_START_OFFSET;
5593 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5594 htab->plt_eh_frame->contents
5595 + PLT_FDE_START_OFFSET);
5596 }
5597 if (htab->plt_eh_frame->sec_info_type
5598 == SEC_INFO_TYPE_EH_FRAME)
5599 {
5600 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5601 htab->plt_eh_frame,
5602 htab->plt_eh_frame->contents))
5603 return FALSE;
5604 }
5605 }
5606
5607 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5608 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5609
5610 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5611 htab_traverse (htab->loc_hash_table,
5612 elf_i386_finish_local_dynamic_symbol,
5613 info);
5614
5615 return TRUE;
5616 }
5617
5618 /* Return an array of PLT entry symbol values. */
5619
5620 static bfd_vma *
5621 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5622 asection *relplt)
5623 {
5624 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5625 arelent *p;
5626 long count, i;
5627 bfd_vma *plt_sym_val;
5628 bfd_vma plt_offset;
5629 bfd_byte *plt_contents;
5630 const struct elf_i386_backend_data *bed
5631 = get_elf_i386_backend_data (abfd);
5632 Elf_Internal_Shdr *hdr;
5633
5634 /* Get the .plt section contents. */
5635 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5636 if (plt_contents == NULL)
5637 return NULL;
5638 if (!bfd_get_section_contents (abfd, (asection *) plt,
5639 plt_contents, 0, plt->size))
5640 {
5641 bad_return:
5642 free (plt_contents);
5643 return NULL;
5644 }
5645
5646 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5647 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5648 goto bad_return;
5649
5650 hdr = &elf_section_data (relplt)->this_hdr;
5651 count = relplt->size / hdr->sh_entsize;
5652
5653 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5654 if (plt_sym_val == NULL)
5655 goto bad_return;
5656
5657 for (i = 0; i < count; i++)
5658 plt_sym_val[i] = -1;
5659
5660 plt_offset = bed->plt->plt_entry_size;
5661 p = relplt->relocation;
5662 for (i = 0; i < count; i++, p++)
5663 {
5664 long reloc_index;
5665
5666 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5667 if (p->howto == NULL)
5668 continue;
5669
5670 if (p->howto->type != R_386_JUMP_SLOT
5671 && p->howto->type != R_386_IRELATIVE)
5672 continue;
5673
5674 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5675 + bed->plt->plt_reloc_offset));
5676 reloc_index /= sizeof (Elf32_External_Rel);
5677 if (reloc_index >= count)
5678 abort ();
5679 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5680 plt_offset += bed->plt->plt_entry_size;
5681
5682 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5683 section. */
5684 if (plt_offset >= plt->size)
5685 break;
5686 }
5687
5688 free (plt_contents);
5689
5690 return plt_sym_val;
5691 }
5692
5693 /* Similar to _bfd_elf_get_synthetic_symtab. */
5694
5695 static long
5696 elf_i386_get_synthetic_symtab (bfd *abfd,
5697 long symcount,
5698 asymbol **syms,
5699 long dynsymcount,
5700 asymbol **dynsyms,
5701 asymbol **ret)
5702 {
5703 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5704 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5705 dynsymcount, dynsyms, ret,
5706 plt,
5707 elf_i386_get_plt_sym_val);
5708 }
5709
5710 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5711
5712 static bfd_boolean
5713 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5714 {
5715 if (h->plt.offset != (bfd_vma) -1
5716 && !h->def_regular
5717 && !h->pointer_equality_needed)
5718 return FALSE;
5719
5720 return _bfd_elf_hash_symbol (h);
5721 }
5722
5723 /* Hook called by the linker routine which adds symbols from an object
5724 file. */
5725
5726 static bfd_boolean
5727 elf_i386_add_symbol_hook (bfd * abfd,
5728 struct bfd_link_info * info,
5729 Elf_Internal_Sym * sym,
5730 const char ** namep ATTRIBUTE_UNUSED,
5731 flagword * flagsp ATTRIBUTE_UNUSED,
5732 asection ** secp ATTRIBUTE_UNUSED,
5733 bfd_vma * valp ATTRIBUTE_UNUSED)
5734 {
5735 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
5736 && (abfd->flags & DYNAMIC) == 0
5737 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5738 elf_tdata (info->output_bfd)->has_gnu_symbols
5739 |= elf_gnu_symbol_unique;
5740
5741 return TRUE;
5742 }
5743
5744 #define TARGET_LITTLE_SYM i386_elf32_vec
5745 #define TARGET_LITTLE_NAME "elf32-i386"
5746 #define ELF_ARCH bfd_arch_i386
5747 #define ELF_TARGET_ID I386_ELF_DATA
5748 #define ELF_MACHINE_CODE EM_386
5749 #define ELF_MAXPAGESIZE 0x1000
5750
5751 #define elf_backend_can_gc_sections 1
5752 #define elf_backend_can_refcount 1
5753 #define elf_backend_want_got_plt 1
5754 #define elf_backend_plt_readonly 1
5755 #define elf_backend_want_plt_sym 0
5756 #define elf_backend_got_header_size 12
5757 #define elf_backend_plt_alignment 4
5758 #define elf_backend_extern_protected_data 1
5759
5760 /* Support RELA for objdump of prelink objects. */
5761 #define elf_info_to_howto elf_i386_info_to_howto_rel
5762 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5763
5764 #define bfd_elf32_mkobject elf_i386_mkobject
5765
5766 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5767 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5768 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5769 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5770 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5771
5772 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5773 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5774 #define elf_backend_check_relocs elf_i386_check_relocs
5775 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5776 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5777 #define elf_backend_fake_sections elf_i386_fake_sections
5778 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5779 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5780 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5781 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
5782 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5783 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5784 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5785 #define elf_backend_relocate_section elf_i386_relocate_section
5786 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5787 #define elf_backend_always_size_sections elf_i386_always_size_sections
5788 #define elf_backend_omit_section_dynsym \
5789 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5790 #define elf_backend_hash_symbol elf_i386_hash_symbol
5791 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5792
5793 #include "elf32-target.h"
5794
5795 /* FreeBSD support. */
5796
5797 #undef TARGET_LITTLE_SYM
5798 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5799 #undef TARGET_LITTLE_NAME
5800 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5801 #undef ELF_OSABI
5802 #define ELF_OSABI ELFOSABI_FREEBSD
5803
5804 /* The kernel recognizes executables as valid only if they carry a
5805 "FreeBSD" label in the ELF header. So we put this label on all
5806 executables and (for simplicity) also all other object files. */
5807
5808 static void
5809 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5810 {
5811 _bfd_elf_post_process_headers (abfd, info);
5812
5813 #ifdef OLD_FREEBSD_ABI_LABEL
5814 {
5815 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5816 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5817 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5818 }
5819 #endif
5820 }
5821
5822 #undef elf_backend_post_process_headers
5823 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5824 #undef elf32_bed
5825 #define elf32_bed elf32_i386_fbsd_bed
5826
5827 #undef elf_backend_add_symbol_hook
5828
5829 #include "elf32-target.h"
5830
5831 /* Solaris 2. */
5832
5833 #undef TARGET_LITTLE_SYM
5834 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5835 #undef TARGET_LITTLE_NAME
5836 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5837
5838 #undef elf_backend_post_process_headers
5839
5840 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5841 objects won't be recognized. */
5842 #undef ELF_OSABI
5843
5844 #undef elf32_bed
5845 #define elf32_bed elf32_i386_sol2_bed
5846
5847 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5848 boundary. */
5849 #undef elf_backend_static_tls_alignment
5850 #define elf_backend_static_tls_alignment 8
5851
5852 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5853
5854 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5855 File, p.63. */
5856 #undef elf_backend_want_plt_sym
5857 #define elf_backend_want_plt_sym 1
5858
5859 #include "elf32-target.h"
5860
5861 /* Intel MCU support. */
5862
5863 static bfd_boolean
5864 elf32_iamcu_elf_object_p (bfd *abfd)
5865 {
5866 /* Set the right machine number for an IAMCU elf32 file. */
5867 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
5868 return TRUE;
5869 }
5870
5871 #undef TARGET_LITTLE_SYM
5872 #define TARGET_LITTLE_SYM iamcu_elf32_vec
5873 #undef TARGET_LITTLE_NAME
5874 #define TARGET_LITTLE_NAME "elf32-iamcu"
5875 #undef ELF_ARCH
5876 #define ELF_ARCH bfd_arch_iamcu
5877
5878 #undef ELF_MACHINE_CODE
5879 #define ELF_MACHINE_CODE EM_IAMCU
5880
5881 #undef ELF_OSABI
5882
5883 #undef elf32_bed
5884 #define elf32_bed elf32_iamcu_bed
5885
5886 #undef elf_backend_object_p
5887 #define elf_backend_object_p elf32_iamcu_elf_object_p
5888
5889 #undef elf_backend_static_tls_alignment
5890
5891 #undef elf_backend_want_plt_sym
5892 #define elf_backend_want_plt_sym 0
5893
5894 #include "elf32-target.h"
5895
5896 /* Restore defaults. */
5897 #undef ELF_ARCH
5898 #define ELF_ARCH bfd_arch_i386
5899 #undef ELF_MACHINE_CODE
5900 #define ELF_MACHINE_CODE EM_386
5901
5902 /* Native Client support. */
5903
5904 #undef TARGET_LITTLE_SYM
5905 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
5906 #undef TARGET_LITTLE_NAME
5907 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
5908 #undef elf32_bed
5909 #define elf32_bed elf32_i386_nacl_bed
5910
5911 #undef ELF_MAXPAGESIZE
5912 #define ELF_MAXPAGESIZE 0x10000
5913
5914 /* Restore defaults. */
5915 #undef ELF_OSABI
5916 #undef elf_backend_want_plt_sym
5917 #define elf_backend_want_plt_sym 0
5918 #undef elf_backend_post_process_headers
5919 #undef elf_backend_static_tls_alignment
5920
5921 /* NaCl uses substantially different PLT entries for the same effects. */
5922
5923 #undef elf_backend_plt_alignment
5924 #define elf_backend_plt_alignment 5
5925 #define NACL_PLT_ENTRY_SIZE 64
5926 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5927
5928 static const bfd_byte elf_i386_nacl_plt0_entry[] =
5929 {
5930 0xff, 0x35, /* pushl contents of address */
5931 0, 0, 0, 0, /* replaced with address of .got + 4. */
5932 0x8b, 0x0d, /* movl contents of address, %ecx */
5933 0, 0, 0, 0, /* replaced with address of .got + 8. */
5934 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5935 0xff, 0xe1 /* jmp *%ecx */
5936 };
5937
5938 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5939 {
5940 0x8b, 0x0d, /* movl contents of address, %ecx */
5941 0, 0, 0, 0, /* replaced with GOT slot address. */
5942 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5943 0xff, 0xe1, /* jmp *%ecx */
5944
5945 /* Pad to the next 32-byte boundary with nop instructions. */
5946 0x90,
5947 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5948 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5949
5950 /* Lazy GOT entries point here (32-byte aligned). */
5951 0x68, /* pushl immediate */
5952 0, 0, 0, 0, /* replaced with reloc offset. */
5953 0xe9, /* jmp relative */
5954 0, 0, 0, 0, /* replaced with offset to .plt. */
5955
5956 /* Pad to the next 32-byte boundary with nop instructions. */
5957 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5958 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5959 0x90, 0x90
5960 };
5961
5962 static const bfd_byte
5963 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5964 {
5965 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
5966 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
5967 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
5968 0xff, 0xe1, /* jmp *%ecx */
5969
5970 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5971 so pad to that size with nop instructions. */
5972 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
5973 };
5974
5975 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5976 {
5977 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
5978 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
5979 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
5980 0xff, 0xe1, /* jmp *%ecx */
5981
5982 /* Pad to the next 32-byte boundary with nop instructions. */
5983 0x90,
5984 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5985 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5986
5987 /* Lazy GOT entries point here (32-byte aligned). */
5988 0x68, /* pushl immediate */
5989 0, 0, 0, 0, /* replaced with offset into relocation table. */
5990 0xe9, /* jmp relative */
5991 0, 0, 0, 0, /* replaced with offset to start of .plt. */
5992
5993 /* Pad to the next 32-byte boundary with nop instructions. */
5994 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5995 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5996 0x90, 0x90
5997 };
5998
5999 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6000 {
6001 #if (PLT_CIE_LENGTH != 20 \
6002 || PLT_FDE_LENGTH != 36 \
6003 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6004 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6005 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6006 #endif
6007 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6008 0, 0, 0, 0, /* CIE ID */
6009 1, /* CIE version */
6010 'z', 'R', 0, /* Augmentation string */
6011 1, /* Code alignment factor */
6012 0x7c, /* Data alignment factor: -4 */
6013 8, /* Return address column */
6014 1, /* Augmentation size */
6015 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6016 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6017 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6018 DW_CFA_nop, DW_CFA_nop,
6019
6020 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6021 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6022 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6023 0, 0, 0, 0, /* .plt size goes here */
6024 0, /* Augmentation size */
6025 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6026 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6027 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6028 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6029 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6030 13, /* Block length */
6031 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6032 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6033 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6034 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6035 DW_CFA_nop, DW_CFA_nop
6036 };
6037
6038 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6039 {
6040 elf_i386_nacl_plt0_entry, /* plt0_entry */
6041 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6042 2, /* plt0_got1_offset */
6043 8, /* plt0_got2_offset */
6044 elf_i386_nacl_plt_entry, /* plt_entry */
6045 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6046 2, /* plt_got_offset */
6047 33, /* plt_reloc_offset */
6048 38, /* plt_plt_offset */
6049 32, /* plt_lazy_offset */
6050 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6051 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6052 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6053 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6054 };
6055
6056 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6057 {
6058 &elf_i386_nacl_plt, /* plt */
6059 0x90, /* plt0_pad_byte: nop insn */
6060 0, /* is_vxworks */
6061 };
6062
6063 static bfd_boolean
6064 elf32_i386_nacl_elf_object_p (bfd *abfd)
6065 {
6066 /* Set the right machine number for a NaCl i386 ELF32 file. */
6067 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6068 return TRUE;
6069 }
6070
6071 #undef elf_backend_arch_data
6072 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6073
6074 #undef elf_backend_object_p
6075 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6076 #undef elf_backend_modify_segment_map
6077 #define elf_backend_modify_segment_map nacl_modify_segment_map
6078 #undef elf_backend_modify_program_headers
6079 #define elf_backend_modify_program_headers nacl_modify_program_headers
6080 #undef elf_backend_final_write_processing
6081 #define elf_backend_final_write_processing nacl_final_write_processing
6082
6083 #include "elf32-target.h"
6084
6085 /* Restore defaults. */
6086 #undef elf_backend_object_p
6087 #undef elf_backend_modify_segment_map
6088 #undef elf_backend_modify_program_headers
6089 #undef elf_backend_final_write_processing
6090
6091 /* VxWorks support. */
6092
6093 #undef TARGET_LITTLE_SYM
6094 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6095 #undef TARGET_LITTLE_NAME
6096 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6097 #undef ELF_OSABI
6098 #undef elf_backend_plt_alignment
6099 #define elf_backend_plt_alignment 4
6100
6101 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6102 {
6103 &elf_i386_plt, /* plt */
6104 0x90, /* plt0_pad_byte */
6105 1, /* is_vxworks */
6106 };
6107
6108 #undef elf_backend_arch_data
6109 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6110
6111 #undef elf_backend_relocs_compatible
6112 #undef elf_backend_add_symbol_hook
6113 #define elf_backend_add_symbol_hook \
6114 elf_vxworks_add_symbol_hook
6115 #undef elf_backend_link_output_symbol_hook
6116 #define elf_backend_link_output_symbol_hook \
6117 elf_vxworks_link_output_symbol_hook
6118 #undef elf_backend_emit_relocs
6119 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6120 #undef elf_backend_final_write_processing
6121 #define elf_backend_final_write_processing \
6122 elf_vxworks_final_write_processing
6123 #undef elf_backend_static_tls_alignment
6124
6125 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6126 define it. */
6127 #undef elf_backend_want_plt_sym
6128 #define elf_backend_want_plt_sym 1
6129
6130 #undef elf32_bed
6131 #define elf32_bed elf32_i386_vxworks_bed
6132
6133 #include "elf32-target.h"
A mirror of the official binutils-gdb repository