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