?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gprofng: fix build with -mx32
[binutils-gdb/blckswan.git] / bfd / elf32-i386.c
blobb034154fb97fd74d743607173c72e568f8e7588d
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2022 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 "elfxx-x86.h"
22 #include "elf-vxworks.h"
23 #include "dwarf2.h"
24 #include "opcode/i386.h"
25
26 /* 386 uses REL relocations instead of RELA. */
27 #define USE_REL 1
28
29 static reloc_howto_type elf_howto_table[]=
30 {
31 HOWTO(R_386_NONE, 0, 3, 0, false, 0, complain_overflow_dont,
32 bfd_elf_generic_reloc, "R_386_NONE",
33 true, 0x00000000, 0x00000000, false),
34 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_dont,
35 bfd_elf_generic_reloc, "R_386_32",
36 true, 0xffffffff, 0xffffffff, false),
37 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_dont,
38 bfd_elf_generic_reloc, "R_386_PC32",
39 true, 0xffffffff, 0xffffffff, true),
40 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_dont,
41 bfd_elf_generic_reloc, "R_386_GOT32",
42 true, 0xffffffff, 0xffffffff, false),
43 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_dont,
44 bfd_elf_generic_reloc, "R_386_PLT32",
45 true, 0xffffffff, 0xffffffff, true),
46 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_dont,
47 bfd_elf_generic_reloc, "R_386_COPY",
48 true, 0xffffffff, 0xffffffff, false),
49 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_dont,
50 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
51 true, 0xffffffff, 0xffffffff, false),
52 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_dont,
53 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
54 true, 0xffffffff, 0xffffffff, false),
55 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_dont,
56 bfd_elf_generic_reloc, "R_386_RELATIVE",
57 true, 0xffffffff, 0xffffffff, false),
58 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_dont,
59 bfd_elf_generic_reloc, "R_386_GOTOFF",
60 true, 0xffffffff, 0xffffffff, false),
61 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_dont,
62 bfd_elf_generic_reloc, "R_386_GOTPC",
63 true, 0xffffffff, 0xffffffff, true),
64
65 /* We have a gap in the reloc numbers here.
66 R_386_standard counts the number up to this point, and
67 R_386_ext_offset is the value to subtract from a reloc type of
68 R_386_16 thru R_386_PC8 to form an index into this table. */
69 #define R_386_standard (R_386_GOTPC + 1)
70 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
71
72 /* These relocs are a GNU extension. */
73 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, false, 0, complain_overflow_dont,
74 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
75 true, 0xffffffff, 0xffffffff, false),
76 HOWTO(R_386_TLS_IE, 0, 2, 32, false, 0, complain_overflow_dont,
77 bfd_elf_generic_reloc, "R_386_TLS_IE",
78 true, 0xffffffff, 0xffffffff, false),
79 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, false, 0, complain_overflow_dont,
80 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
81 true, 0xffffffff, 0xffffffff, false),
82 HOWTO(R_386_TLS_LE, 0, 2, 32, false, 0, complain_overflow_dont,
83 bfd_elf_generic_reloc, "R_386_TLS_LE",
84 true, 0xffffffff, 0xffffffff, false),
85 HOWTO(R_386_TLS_GD, 0, 2, 32, false, 0, complain_overflow_dont,
86 bfd_elf_generic_reloc, "R_386_TLS_GD",
87 true, 0xffffffff, 0xffffffff, false),
88 HOWTO(R_386_TLS_LDM, 0, 2, 32, false, 0, complain_overflow_dont,
89 bfd_elf_generic_reloc, "R_386_TLS_LDM",
90 true, 0xffffffff, 0xffffffff, false),
91 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
92 bfd_elf_generic_reloc, "R_386_16",
93 true, 0xffff, 0xffff, false),
94 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_386_PC16",
96 true, 0xffff, 0xffff, true),
97 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_386_8",
99 true, 0xff, 0xff, false),
100 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
101 bfd_elf_generic_reloc, "R_386_PC8",
102 true, 0xff, 0xff, true),
103
104 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
105 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
106 /* These are common with Solaris TLS implementation. */
107 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, false, 0, complain_overflow_dont,
108 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
109 true, 0xffffffff, 0xffffffff, false),
110 HOWTO(R_386_TLS_IE_32, 0, 2, 32, false, 0, complain_overflow_dont,
111 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
112 true, 0xffffffff, 0xffffffff, false),
113 HOWTO(R_386_TLS_LE_32, 0, 2, 32, false, 0, complain_overflow_dont,
114 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
115 true, 0xffffffff, 0xffffffff, false),
116 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, false, 0, complain_overflow_dont,
117 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
118 true, 0xffffffff, 0xffffffff, false),
119 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, false, 0, complain_overflow_dont,
120 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
121 true, 0xffffffff, 0xffffffff, false),
122 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, false, 0, complain_overflow_dont,
123 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
124 true, 0xffffffff, 0xffffffff, false),
125 HOWTO(R_386_SIZE32, 0, 2, 32, false, 0, complain_overflow_dont,
126 bfd_elf_generic_reloc, "R_386_SIZE32",
127 true, 0xffffffff, 0xffffffff, false),
128 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, false, 0, complain_overflow_dont,
129 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
130 true, 0xffffffff, 0xffffffff, false),
131 HOWTO(R_386_TLS_DESC_CALL, 0, 3, 0, false, 0, complain_overflow_dont,
132 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
133 false, 0, 0, false),
134 HOWTO(R_386_TLS_DESC, 0, 2, 32, false, 0, complain_overflow_dont,
135 bfd_elf_generic_reloc, "R_386_TLS_DESC",
136 true, 0xffffffff, 0xffffffff, false),
137 HOWTO(R_386_IRELATIVE, 0, 2, 32, false, 0, complain_overflow_dont,
138 bfd_elf_generic_reloc, "R_386_IRELATIVE",
139 true, 0xffffffff, 0xffffffff, false),
140 HOWTO(R_386_GOT32X, 0, 2, 32, false, 0, complain_overflow_dont,
141 bfd_elf_generic_reloc, "R_386_GOT32X",
142 true, 0xffffffff, 0xffffffff, false),
143
144 /* Another gap. */
145 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
146 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
147
148 /* GNU extension to record C++ vtable hierarchy. */
149 HOWTO (R_386_GNU_VTINHERIT, /* type */
150 0, /* rightshift */
151 2, /* size (0 = byte, 1 = short, 2 = long) */
152 0, /* bitsize */
153 false, /* pc_relative */
154 0, /* bitpos */
155 complain_overflow_dont, /* complain_on_overflow */
156 NULL, /* special_function */
157 "R_386_GNU_VTINHERIT", /* name */
158 false, /* partial_inplace */
159 0, /* src_mask */
160 0, /* dst_mask */
161 false), /* pcrel_offset */
162
163 /* GNU extension to record C++ vtable member usage. */
164 HOWTO (R_386_GNU_VTENTRY, /* type */
165 0, /* rightshift */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
167 0, /* bitsize */
168 false, /* pc_relative */
169 0, /* bitpos */
170 complain_overflow_dont, /* complain_on_overflow */
171 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
172 "R_386_GNU_VTENTRY", /* name */
173 false, /* partial_inplace */
174 0, /* src_mask */
175 0, /* dst_mask */
176 false) /* pcrel_offset */
177
178 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
179
180 };
181
182 #ifdef DEBUG_GEN_RELOC
183 #define TRACE(str) \
184 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
185 #else
186 #define TRACE(str)
187 #endif
188
189 static reloc_howto_type *
190 elf_i386_reloc_type_lookup (bfd *abfd,
191 bfd_reloc_code_real_type code)
192 {
193 switch (code)
194 {
195 case BFD_RELOC_NONE:
196 TRACE ("BFD_RELOC_NONE");
197 return &elf_howto_table[R_386_NONE];
198
199 case BFD_RELOC_32:
200 TRACE ("BFD_RELOC_32");
201 return &elf_howto_table[R_386_32];
202
203 case BFD_RELOC_CTOR:
204 TRACE ("BFD_RELOC_CTOR");
205 return &elf_howto_table[R_386_32];
206
207 case BFD_RELOC_32_PCREL:
208 TRACE ("BFD_RELOC_PC32");
209 return &elf_howto_table[R_386_PC32];
210
211 case BFD_RELOC_386_GOT32:
212 TRACE ("BFD_RELOC_386_GOT32");
213 return &elf_howto_table[R_386_GOT32];
214
215 case BFD_RELOC_386_PLT32:
216 TRACE ("BFD_RELOC_386_PLT32");
217 return &elf_howto_table[R_386_PLT32];
218
219 case BFD_RELOC_386_COPY:
220 TRACE ("BFD_RELOC_386_COPY");
221 return &elf_howto_table[R_386_COPY];
222
223 case BFD_RELOC_386_GLOB_DAT:
224 TRACE ("BFD_RELOC_386_GLOB_DAT");
225 return &elf_howto_table[R_386_GLOB_DAT];
226
227 case BFD_RELOC_386_JUMP_SLOT:
228 TRACE ("BFD_RELOC_386_JUMP_SLOT");
229 return &elf_howto_table[R_386_JUMP_SLOT];
230
231 case BFD_RELOC_386_RELATIVE:
232 TRACE ("BFD_RELOC_386_RELATIVE");
233 return &elf_howto_table[R_386_RELATIVE];
234
235 case BFD_RELOC_386_GOTOFF:
236 TRACE ("BFD_RELOC_386_GOTOFF");
237 return &elf_howto_table[R_386_GOTOFF];
238
239 case BFD_RELOC_386_GOTPC:
240 TRACE ("BFD_RELOC_386_GOTPC");
241 return &elf_howto_table[R_386_GOTPC];
242
243 /* These relocs are a GNU extension. */
244 case BFD_RELOC_386_TLS_TPOFF:
245 TRACE ("BFD_RELOC_386_TLS_TPOFF");
246 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
247
248 case BFD_RELOC_386_TLS_IE:
249 TRACE ("BFD_RELOC_386_TLS_IE");
250 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
251
252 case BFD_RELOC_386_TLS_GOTIE:
253 TRACE ("BFD_RELOC_386_TLS_GOTIE");
254 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
255
256 case BFD_RELOC_386_TLS_LE:
257 TRACE ("BFD_RELOC_386_TLS_LE");
258 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
259
260 case BFD_RELOC_386_TLS_GD:
261 TRACE ("BFD_RELOC_386_TLS_GD");
262 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
263
264 case BFD_RELOC_386_TLS_LDM:
265 TRACE ("BFD_RELOC_386_TLS_LDM");
266 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
267
268 case BFD_RELOC_16:
269 TRACE ("BFD_RELOC_16");
270 return &elf_howto_table[R_386_16 - R_386_ext_offset];
271
272 case BFD_RELOC_16_PCREL:
273 TRACE ("BFD_RELOC_16_PCREL");
274 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
275
276 case BFD_RELOC_8:
277 TRACE ("BFD_RELOC_8");
278 return &elf_howto_table[R_386_8 - R_386_ext_offset];
279
280 case BFD_RELOC_8_PCREL:
281 TRACE ("BFD_RELOC_8_PCREL");
282 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
283
284 /* Common with Sun TLS implementation. */
285 case BFD_RELOC_386_TLS_LDO_32:
286 TRACE ("BFD_RELOC_386_TLS_LDO_32");
287 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
288
289 case BFD_RELOC_386_TLS_IE_32:
290 TRACE ("BFD_RELOC_386_TLS_IE_32");
291 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
292
293 case BFD_RELOC_386_TLS_LE_32:
294 TRACE ("BFD_RELOC_386_TLS_LE_32");
295 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
296
297 case BFD_RELOC_386_TLS_DTPMOD32:
298 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
299 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
300
301 case BFD_RELOC_386_TLS_DTPOFF32:
302 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
303 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
304
305 case BFD_RELOC_386_TLS_TPOFF32:
306 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
307 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
308
309 case BFD_RELOC_SIZE32:
310 TRACE ("BFD_RELOC_SIZE32");
311 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
312
313 case BFD_RELOC_386_TLS_GOTDESC:
314 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
315 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
316
317 case BFD_RELOC_386_TLS_DESC_CALL:
318 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
319 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
320
321 case BFD_RELOC_386_TLS_DESC:
322 TRACE ("BFD_RELOC_386_TLS_DESC");
323 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
324
325 case BFD_RELOC_386_IRELATIVE:
326 TRACE ("BFD_RELOC_386_IRELATIVE");
327 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
328
329 case BFD_RELOC_386_GOT32X:
330 TRACE ("BFD_RELOC_386_GOT32X");
331 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
332
333 case BFD_RELOC_VTABLE_INHERIT:
334 TRACE ("BFD_RELOC_VTABLE_INHERIT");
335 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
336
337 case BFD_RELOC_VTABLE_ENTRY:
338 TRACE ("BFD_RELOC_VTABLE_ENTRY");
339 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
340
341 default:
342 TRACE ("Unknown");
343 /* xgettext:c-format */
344 _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
345 abfd, (int) code);
346 bfd_set_error (bfd_error_bad_value);
347 return NULL;
348 }
349 }
350
351 static reloc_howto_type *
352 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
353 const char *r_name)
354 {
355 unsigned int i;
356
357 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
358 if (elf_howto_table[i].name != NULL
359 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
360 return &elf_howto_table[i];
361
362 return NULL;
363 }
364
365 static reloc_howto_type *
366 elf_i386_rtype_to_howto (unsigned r_type)
367 {
368 unsigned int indx;
369
370 if ((indx = r_type) >= R_386_standard
371 && ((indx = r_type - R_386_ext_offset) - R_386_standard
372 >= R_386_ext - R_386_standard)
373 && ((indx = r_type - R_386_tls_offset) - R_386_ext
374 >= R_386_ext2 - R_386_ext)
375 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
376 >= R_386_vt - R_386_ext2))
377 return NULL;
378 /* PR 17512: file: 0f67f69d. */
379 if (elf_howto_table [indx].type != r_type)
380 return NULL;
381 return &elf_howto_table[indx];
382 }
383
384 static bool
385 elf_i386_info_to_howto_rel (bfd *abfd,
386 arelent *cache_ptr,
387 Elf_Internal_Rela *dst)
388 {
389 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
390
391 if ((cache_ptr->howto = elf_i386_rtype_to_howto (r_type)) == NULL)
392 {
393 /* xgettext:c-format */
394 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
395 abfd, r_type);
396 bfd_set_error (bfd_error_bad_value);
397 return false;
398 }
399
400 return true;
401 }
402
403 /* Return whether a symbol name implies a local label. The UnixWare
404 2.1 cc generates temporary symbols that start with .X, so we
405 recognize them here. FIXME: do other SVR4 compilers also use .X?.
406 If so, we should move the .X recognition into
407 _bfd_elf_is_local_label_name. */
408
409 static bool
410 elf_i386_is_local_label_name (bfd *abfd, const char *name)
411 {
412 if (name[0] == '.' && name[1] == 'X')
413 return true;
414
415 return _bfd_elf_is_local_label_name (abfd, name);
416 }
417 \f
418 /* Support for core dump NOTE sections. */
419
420 static bool
421 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
422 {
423 int offset;
424 size_t size;
425
426 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
427 {
428 int pr_version = bfd_get_32 (abfd, note->descdata);
429
430 if (pr_version != 1)
431 return false;
432
433 /* pr_cursig */
434 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
435
436 /* pr_pid */
437 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
438
439 /* pr_reg */
440 offset = 28;
441 size = bfd_get_32 (abfd, note->descdata + 8);
442 }
443 else
444 {
445 switch (note->descsz)
446 {
447 default:
448 return false;
449
450 case 144: /* Linux/i386 */
451 /* pr_cursig */
452 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
453
454 /* pr_pid */
455 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
456
457 /* pr_reg */
458 offset = 72;
459 size = 68;
460
461 break;
462 }
463 }
464
465 /* Make a ".reg/999" section. */
466 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
467 size, note->descpos + offset);
468 }
469
470 static bool
471 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
472 {
473 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
474 {
475 int pr_version = bfd_get_32 (abfd, note->descdata);
476
477 if (pr_version != 1)
478 return false;
479
480 elf_tdata (abfd)->core->program
481 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
482 elf_tdata (abfd)->core->command
483 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
484 }
485 else
486 {
487 switch (note->descsz)
488 {
489 default:
490 return false;
491
492 case 124: /* Linux/i386 elf_prpsinfo. */
493 elf_tdata (abfd)->core->pid
494 = bfd_get_32 (abfd, note->descdata + 12);
495 elf_tdata (abfd)->core->program
496 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
497 elf_tdata (abfd)->core->command
498 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
499 }
500 }
501
502 /* Note that for some reason, a spurious space is tacked
503 onto the end of the args in some (at least one anyway)
504 implementations, so strip it off if it exists. */
505 {
506 char *command = elf_tdata (abfd)->core->command;
507 int n = strlen (command);
508
509 if (0 < n && command[n - 1] == ' ')
510 command[n - 1] = '\0';
511 }
512
513 return true;
514 }
515 \f
516 /* Functions for the i386 ELF linker.
517
518 In order to gain some understanding of code in this file without
519 knowing all the intricate details of the linker, note the
520 following:
521
522 Functions named elf_i386_* are called by external routines, other
523 functions are only called locally. elf_i386_* functions appear
524 in this file more or less in the order in which they are called
525 from external routines. eg. elf_i386_scan_relocs is called
526 early in the link process, elf_i386_finish_dynamic_sections is
527 one of the last functions. */
528
529 /* The size in bytes of an entry in the lazy procedure linkage table. */
530
531 #define LAZY_PLT_ENTRY_SIZE 16
532
533 /* The size in bytes of an entry in the non-lazy procedure linkage
534 table. */
535
536 #define NON_LAZY_PLT_ENTRY_SIZE 8
537
538 /* The first entry in an absolute lazy procedure linkage table looks
539 like this. See the SVR4 ABI i386 supplement to see how this works.
540 Will be padded to LAZY_PLT_ENTRY_SIZE with lazy_plt->plt0_pad_byte. */
541
542 static const bfd_byte elf_i386_lazy_plt0_entry[12] =
543 {
544 0xff, 0x35, /* pushl contents of address */
545 0, 0, 0, 0, /* replaced with address of .got + 4. */
546 0xff, 0x25, /* jmp indirect */
547 0, 0, 0, 0 /* replaced with address of .got + 8. */
548 };
549
550 /* Subsequent entries in an absolute lazy procedure linkage table look
551 like this. */
552
553 static const bfd_byte elf_i386_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
554 {
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
557 0x68, /* pushl immediate */
558 0, 0, 0, 0, /* replaced with offset into relocation table. */
559 0xe9, /* jmp relative */
560 0, 0, 0, 0 /* replaced with offset to start of .plt. */
561 };
562
563 /* The first entry in a PIC lazy procedure linkage table look like
564 this. Will be padded to LAZY_PLT_ENTRY_SIZE with
565 lazy_plt->plt0_pad_byte. */
566
567 static const bfd_byte elf_i386_pic_lazy_plt0_entry[12] =
568 {
569 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
570 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
571 };
572
573 /* Subsequent entries in a PIC lazy procedure linkage table look like
574 this. */
575
576 static const bfd_byte elf_i386_pic_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
577 {
578 0xff, 0xa3, /* jmp *offset(%ebx) */
579 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
580 0x68, /* pushl immediate */
581 0, 0, 0, 0, /* replaced with offset into relocation table. */
582 0xe9, /* jmp relative */
583 0, 0, 0, 0 /* replaced with offset to start of .plt. */
584 };
585
586 /* Entries in the non-lazy procedure linkage table look like this. */
587
588 static const bfd_byte elf_i386_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
589 {
590 0xff, 0x25, /* jmp indirect */
591 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
592 0x66, 0x90 /* xchg %ax,%ax */
593 };
594
595 /* Entries in the PIC non-lazy procedure linkage table look like
596 this. */
597
598 static const bfd_byte elf_i386_pic_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
599 {
600 0xff, 0xa3, /* jmp *offset(%ebx) */
601 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
602 0x66, 0x90 /* xchg %ax,%ax */
603 };
604
605 /* The first entry in an absolute IBT-enabled lazy procedure linkage
606 table looks like this. */
607
608 static const bfd_byte elf_i386_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
609 {
610 0xff, 0x35, 0, 0, 0, 0, /* pushl GOT[1] */
611 0xff, 0x25, 0, 0, 0, 0, /* jmp *GOT[2] */
612 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
613 };
614
615 /* Subsequent entries for an absolute IBT-enabled lazy procedure linkage
616 table look like this. Subsequent entries for a PIC IBT-enabled lazy
617 procedure linkage table are the same. */
618
619 static const bfd_byte elf_i386_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
620 {
621 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
622 0x68, 0, 0, 0, 0, /* pushl immediate */
623 0xe9, 0, 0, 0, 0, /* jmp relative */
624 0x66, 0x90 /* xchg %ax,%ax */
625 };
626
627 /* The first entry in a PIC IBT-enabled lazy procedure linkage table
628 look like. */
629
630 static const bfd_byte elf_i386_pic_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
631 {
632 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
633 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
634 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
635 };
636
637 /* Entries for branches with IBT-enabled in the absolute non-lazey
638 procedure linkage table look like this. They have the same size
639 as the lazy PLT entry. */
640
641 static const bfd_byte elf_i386_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
642 {
643 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
644 0xff, 0x25, 0, 0, 0, 0, /* jmp *name@GOT */
645 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
646 };
647
648 /* Entries for branches with IBT-enabled in the PIC non-lazey procedure
649 linkage table look like this. They have the same size as the lazy
650 PLT entry. */
651
652 static const bfd_byte elf_i386_pic_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
653 {
654 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
655 0xff, 0xa3, 0, 0, 0, 0, /* jmp *name@GOT(%ebx) */
656 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
657 };
658
659 /* .eh_frame covering the lazy .plt section. */
660
661 static const bfd_byte elf_i386_eh_frame_lazy_plt[] =
662 {
663 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
664 0, 0, 0, 0, /* CIE ID */
665 1, /* CIE version */
666 'z', 'R', 0, /* Augmentation string */
667 1, /* Code alignment factor */
668 0x7c, /* Data alignment factor */
669 8, /* Return address column */
670 1, /* Augmentation size */
671 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
672 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
673 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
674 DW_CFA_nop, DW_CFA_nop,
675
676 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
677 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
678 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
679 0, 0, 0, 0, /* .plt size goes here */
680 0, /* Augmentation size */
681 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
682 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
683 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
684 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
685 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
686 11, /* Block length */
687 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
688 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
689 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
690 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
691 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
692 };
693
694 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
695
696 static const bfd_byte elf_i386_eh_frame_lazy_ibt_plt[] =
697 {
698 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
699 0, 0, 0, 0, /* CIE ID */
700 1, /* CIE version */
701 'z', 'R', 0, /* Augmentation string */
702 1, /* Code alignment factor */
703 0x7c, /* Data alignment factor */
704 8, /* Return address column */
705 1, /* Augmentation size */
706 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
707 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
708 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
709 DW_CFA_nop, DW_CFA_nop,
710
711 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
712 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
713 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
714 0, 0, 0, 0, /* .plt size goes here */
715 0, /* Augmentation size */
716 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
717 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
718 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
719 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
720 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
721 11, /* Block length */
722 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
723 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
724 DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
725 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
726 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
727 };
728
729 /* .eh_frame covering the non-lazy .plt section. */
730
731 static const bfd_byte elf_i386_eh_frame_non_lazy_plt[] =
732 {
733 #define PLT_GOT_FDE_LENGTH 16
734 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
735 0, 0, 0, 0, /* CIE ID */
736 1, /* CIE version */
737 'z', 'R', 0, /* Augmentation string */
738 1, /* Code alignment factor */
739 0x7c, /* Data alignment factor */
740 8, /* Return address column */
741 1, /* Augmentation size */
742 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
743 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
744 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
745 DW_CFA_nop, DW_CFA_nop,
746
747 PLT_GOT_FDE_LENGTH, 0, 0, 0, /* FDE length */
748 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
749 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
750 0, 0, 0, 0, /* non-lazy .plt size goes here */
751 0, /* Augmentation size */
752 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
753 };
754
755 /* These are the standard parameters. */
756 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_plt =
757 {
758 elf_i386_lazy_plt0_entry, /* plt0_entry */
759 sizeof (elf_i386_lazy_plt0_entry), /* plt0_entry_size */
760 elf_i386_lazy_plt_entry, /* plt_entry */
761 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
762 NULL, /* plt_tlsdesc_entry */
763 0, /* plt_tlsdesc_entry_size*/
764 0, /* plt_tlsdesc_got1_offset */
765 0, /* plt_tlsdesc_got2_offset */
766 0, /* plt_tlsdesc_got1_insn_end */
767 0, /* plt_tlsdesc_got2_insn_end */
768 2, /* plt0_got1_offset */
769 8, /* plt0_got2_offset */
770 0, /* plt0_got2_insn_end */
771 2, /* plt_got_offset */
772 7, /* plt_reloc_offset */
773 12, /* plt_plt_offset */
774 0, /* plt_got_insn_size */
775 0, /* plt_plt_insn_end */
776 6, /* plt_lazy_offset */
777 elf_i386_pic_lazy_plt0_entry, /* pic_plt0_entry */
778 elf_i386_pic_lazy_plt_entry, /* pic_plt_entry */
779 elf_i386_eh_frame_lazy_plt, /* eh_frame_plt */
780 sizeof (elf_i386_eh_frame_lazy_plt) /* eh_frame_plt_size */
781 };
782
783 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_plt =
784 {
785 elf_i386_non_lazy_plt_entry, /* plt_entry */
786 elf_i386_pic_non_lazy_plt_entry, /* pic_plt_entry */
787 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
788 2, /* plt_got_offset */
789 0, /* plt_got_insn_size */
790 elf_i386_eh_frame_non_lazy_plt, /* eh_frame_plt */
791 sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
792 };
793
794 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_ibt_plt =
795 {
796 elf_i386_lazy_ibt_plt0_entry, /* plt0_entry */
797 sizeof (elf_i386_lazy_ibt_plt0_entry), /* plt0_entry_size */
798 elf_i386_lazy_ibt_plt_entry, /* plt_entry */
799 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
800 NULL, /* plt_tlsdesc_entry */
801 0, /* plt_tlsdesc_entry_size*/
802 0, /* plt_tlsdesc_got1_offset */
803 0, /* plt_tlsdesc_got2_offset */
804 0, /* plt_tlsdesc_got1_insn_end */
805 0, /* plt_tlsdesc_got2_insn_end */
806 2, /* plt0_got1_offset */
807 8, /* plt0_got2_offset */
808 0, /* plt0_got2_insn_end */
809 4+2, /* plt_got_offset */
810 4+1, /* plt_reloc_offset */
811 4+6, /* plt_plt_offset */
812 0, /* plt_got_insn_size */
813 0, /* plt_plt_insn_end */
814 0, /* plt_lazy_offset */
815 elf_i386_pic_lazy_ibt_plt0_entry, /* pic_plt0_entry */
816 elf_i386_lazy_ibt_plt_entry, /* pic_plt_entry */
817 elf_i386_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
818 sizeof (elf_i386_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
819 };
820
821 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_ibt_plt =
822 {
823 elf_i386_non_lazy_ibt_plt_entry, /* plt_entry */
824 elf_i386_pic_non_lazy_ibt_plt_entry,/* pic_plt_entry */
825 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
826 4+2, /* plt_got_offset */
827 0, /* plt_got_insn_size */
828 elf_i386_eh_frame_non_lazy_plt, /* eh_frame_plt */
829 sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
830 };
831 \f
832
833 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
834 for the PLTResolve stub and then for each PLT entry. */
835 #define PLTRESOLVE_RELOCS_SHLIB 0
836 #define PLTRESOLVE_RELOCS 2
837 #define PLT_NON_JUMP_SLOT_RELOCS 2
838
839 /* Return TRUE if the TLS access code sequence support transition
840 from R_TYPE. */
841
842 static bool
843 elf_i386_check_tls_transition (asection *sec,
844 bfd_byte *contents,
845 Elf_Internal_Shdr *symtab_hdr,
846 struct elf_link_hash_entry **sym_hashes,
847 unsigned int r_type,
848 const Elf_Internal_Rela *rel,
849 const Elf_Internal_Rela *relend)
850 {
851 unsigned int val, type, reg;
852 unsigned long r_symndx;
853 struct elf_link_hash_entry *h;
854 bfd_vma offset;
855 bfd_byte *call;
856 bool indirect_call;
857
858 offset = rel->r_offset;
859 switch (r_type)
860 {
861 case R_386_TLS_GD:
862 case R_386_TLS_LDM:
863 if (offset < 2 || (rel + 1) >= relend)
864 return false;
865
866 indirect_call = false;
867 call = contents + offset + 4;
868 val = *(call - 5);
869 type = *(call - 6);
870 if (r_type == R_386_TLS_GD)
871 {
872 /* Check transition from GD access model. Only
873 leal foo@tlsgd(,%ebx,1), %eax
874 call ___tls_get_addr@PLT
875 or
876 leal foo@tlsgd(%ebx) %eax
877 call ___tls_get_addr@PLT
878 nop
879 or
880 leal foo@tlsgd(%reg), %eax
881 call *___tls_get_addr@GOT(%reg)
882 which may be converted to
883 addr32 call ___tls_get_addr
884 can transit to different access model. */
885 if ((offset + 10) > sec->size
886 || (type != 0x8d && type != 0x04))
887 return false;
888
889 if (type == 0x04)
890 {
891 /* leal foo@tlsgd(,%ebx,1), %eax
892 call ___tls_get_addr@PLT */
893 if (offset < 3)
894 return false;
895
896 if (*(call - 7) != 0x8d
897 || val != 0x1d
898 || call[0] != 0xe8)
899 return false;
900 }
901 else
902 {
903 /* This must be
904 leal foo@tlsgd(%ebx), %eax
905 call ___tls_get_addr@PLT
906 nop
907 or
908 leal foo@tlsgd(%reg), %eax
909 call *___tls_get_addr@GOT(%reg)
910 which may be converted to
911 addr32 call ___tls_get_addr
912
913 %eax can't be used as the GOT base register since it
914 is used to pass parameter to ___tls_get_addr. */
915 reg = val & 7;
916 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
917 return false;
918
919 indirect_call = call[0] == 0xff;
920 if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
921 && !(call[0] == 0x67 && call[1] == 0xe8)
922 && !(indirect_call
923 && (call[1] & 0xf8) == 0x90
924 && (call[1] & 0x7) == reg))
925 return false;
926 }
927 }
928 else
929 {
930 /* Check transition from LD access model. Only
931 leal foo@tlsldm(%ebx), %eax
932 call ___tls_get_addr@PLT
933 or
934 leal foo@tlsldm(%reg), %eax
935 call *___tls_get_addr@GOT(%reg)
936 which may be converted to
937 addr32 call ___tls_get_addr
938 can transit to different access model. */
939 if (type != 0x8d || (offset + 9) > sec->size)
940 return false;
941
942 /* %eax can't be used as the GOT base register since it is
943 used to pass parameter to ___tls_get_addr. */
944 reg = val & 7;
945 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
946 return false;
947
948 indirect_call = call[0] == 0xff;
949 if (!(reg == 3 && call[0] == 0xe8)
950 && !(call[0] == 0x67 && call[1] == 0xe8)
951 && !(indirect_call
952 && (call[1] & 0xf8) == 0x90
953 && (call[1] & 0x7) == reg))
954 return false;
955 }
956
957 r_symndx = ELF32_R_SYM (rel[1].r_info);
958 if (r_symndx < symtab_hdr->sh_info)
959 return false;
960
961 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
962 if (h == NULL
963 || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
964 return false;
965 else if (indirect_call)
966 return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
967 else
968 return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
969 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
970
971 case R_386_TLS_IE:
972 /* Check transition from IE access model:
973 movl foo@indntpoff(%rip), %eax
974 movl foo@indntpoff(%rip), %reg
975 addl foo@indntpoff(%rip), %reg
976 */
977
978 if (offset < 1 || (offset + 4) > sec->size)
979 return false;
980
981 /* Check "movl foo@tpoff(%rip), %eax" first. */
982 val = bfd_get_8 (abfd, contents + offset - 1);
983 if (val == 0xa1)
984 return true;
985
986 if (offset < 2)
987 return false;
988
989 /* Check movl|addl foo@tpoff(%rip), %reg. */
990 type = bfd_get_8 (abfd, contents + offset - 2);
991 return ((type == 0x8b || type == 0x03)
992 && (val & 0xc7) == 0x05);
993
994 case R_386_TLS_GOTIE:
995 case R_386_TLS_IE_32:
996 /* Check transition from {IE_32,GOTIE} access model:
997 subl foo@{tpoff,gontoff}(%reg1), %reg2
998 movl foo@{tpoff,gontoff}(%reg1), %reg2
999 addl foo@{tpoff,gontoff}(%reg1), %reg2
1000 */
1001
1002 if (offset < 2 || (offset + 4) > sec->size)
1003 return false;
1004
1005 val = bfd_get_8 (abfd, contents + offset - 1);
1006 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1007 return false;
1008
1009 type = bfd_get_8 (abfd, contents + offset - 2);
1010 return type == 0x8b || type == 0x2b || type == 0x03;
1011
1012 case R_386_TLS_GOTDESC:
1013 /* Check transition from GDesc access model:
1014 leal x@tlsdesc(%ebx), %eax
1015
1016 Make sure it's a leal adding ebx to a 32-bit offset
1017 into any register, although it's probably almost always
1018 going to be eax. */
1019
1020 if (offset < 2 || (offset + 4) > sec->size)
1021 return false;
1022
1023 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1024 return false;
1025
1026 val = bfd_get_8 (abfd, contents + offset - 1);
1027 return (val & 0xc7) == 0x83;
1028
1029 case R_386_TLS_DESC_CALL:
1030 /* Check transition from GDesc access model:
1031 call *x@tlsdesc(%eax)
1032 */
1033 if (offset + 2 <= sec->size)
1034 {
1035 /* Make sure that it's a call *x@tlsdesc(%eax). */
1036 call = contents + offset;
1037 return call[0] == 0xff && call[1] == 0x10;
1038 }
1039
1040 return false;
1041
1042 default:
1043 abort ();
1044 }
1045 }
1046
1047 /* Return TRUE if the TLS access transition is OK or no transition
1048 will be performed. Update R_TYPE if there is a transition. */
1049
1050 static bool
1051 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1052 asection *sec, bfd_byte *contents,
1053 Elf_Internal_Shdr *symtab_hdr,
1054 struct elf_link_hash_entry **sym_hashes,
1055 unsigned int *r_type, int tls_type,
1056 const Elf_Internal_Rela *rel,
1057 const Elf_Internal_Rela *relend,
1058 struct elf_link_hash_entry *h,
1059 unsigned long r_symndx,
1060 bool from_relocate_section)
1061 {
1062 unsigned int from_type = *r_type;
1063 unsigned int to_type = from_type;
1064 bool check = true;
1065
1066 /* Skip TLS transition for functions. */
1067 if (h != NULL
1068 && (h->type == STT_FUNC
1069 || h->type == STT_GNU_IFUNC))
1070 return true;
1071
1072 switch (from_type)
1073 {
1074 case R_386_TLS_GD:
1075 case R_386_TLS_GOTDESC:
1076 case R_386_TLS_DESC_CALL:
1077 case R_386_TLS_IE_32:
1078 case R_386_TLS_IE:
1079 case R_386_TLS_GOTIE:
1080 if (bfd_link_executable (info))
1081 {
1082 if (h == NULL)
1083 to_type = R_386_TLS_LE_32;
1084 else if (from_type != R_386_TLS_IE
1085 && from_type != R_386_TLS_GOTIE)
1086 to_type = R_386_TLS_IE_32;
1087 }
1088
1089 /* When we are called from elf_i386_relocate_section, there may
1090 be additional transitions based on TLS_TYPE. */
1091 if (from_relocate_section)
1092 {
1093 unsigned int new_to_type = to_type;
1094
1095 if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
1096 new_to_type = R_386_TLS_LE_32;
1097
1098 if (to_type == R_386_TLS_GD
1099 || to_type == R_386_TLS_GOTDESC
1100 || to_type == R_386_TLS_DESC_CALL)
1101 {
1102 if (tls_type == GOT_TLS_IE_POS)
1103 new_to_type = R_386_TLS_GOTIE;
1104 else if (tls_type & GOT_TLS_IE)
1105 new_to_type = R_386_TLS_IE_32;
1106 }
1107
1108 /* We checked the transition before when we were called from
1109 elf_i386_scan_relocs. We only want to check the new
1110 transition which hasn't been checked before. */
1111 check = new_to_type != to_type && from_type == to_type;
1112 to_type = new_to_type;
1113 }
1114
1115 break;
1116
1117 case R_386_TLS_LDM:
1118 if (bfd_link_executable (info))
1119 to_type = R_386_TLS_LE_32;
1120 break;
1121
1122 default:
1123 return true;
1124 }
1125
1126 /* Return TRUE if there is no transition. */
1127 if (from_type == to_type)
1128 return true;
1129
1130 /* Check if the transition can be performed. */
1131 if (check
1132 && ! elf_i386_check_tls_transition (sec, contents,
1133 symtab_hdr, sym_hashes,
1134 from_type, rel, relend))
1135 {
1136 reloc_howto_type *from, *to;
1137 const char *name;
1138
1139 from = elf_i386_rtype_to_howto (from_type);
1140 to = elf_i386_rtype_to_howto (to_type);
1141
1142 if (h)
1143 name = h->root.root.string;
1144 else
1145 {
1146 struct elf_x86_link_hash_table *htab;
1147
1148 htab = elf_x86_hash_table (info, I386_ELF_DATA);
1149 if (htab == NULL)
1150 name = "*unknown*";
1151 else
1152 {
1153 Elf_Internal_Sym *isym;
1154
1155 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1156 abfd, r_symndx);
1157 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1158 }
1159 }
1160
1161 _bfd_error_handler
1162 /* xgettext:c-format */
1163 (_("%pB: TLS transition from %s to %s against `%s'"
1164 " at %#" PRIx64 " in section `%pA' failed"),
1165 abfd, from->name, to->name, name,
1166 (uint64_t) rel->r_offset, sec);
1167 bfd_set_error (bfd_error_bad_value);
1168 return false;
1169 }
1170
1171 *r_type = to_type;
1172 return true;
1173 }
1174
1175 /* With the local symbol, foo, we convert
1176 mov foo@GOT[(%reg1)], %reg2
1177 to
1178 lea foo[@GOTOFF(%reg1)], %reg2
1179 and convert
1180 call/jmp *foo@GOT[(%reg)]
1181 to
1182 nop call foo/jmp foo nop
1183 When PIC is false, convert
1184 test %reg1, foo@GOT[(%reg2)]
1185 to
1186 test $foo, %reg1
1187 and convert
1188 binop foo@GOT[(%reg1)], %reg2
1189 to
1190 binop $foo, %reg2
1191 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1192 instructions. */
1193
1194 static
1195 bool
1196 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1197 bfd_byte *contents,
1198 unsigned int *r_type_p,
1199 Elf_Internal_Rela *irel,
1200 struct elf_link_hash_entry *h,
1201 bool *converted,
1202 struct bfd_link_info *link_info)
1203 {
1204 struct elf_x86_link_hash_table *htab;
1205 unsigned int opcode;
1206 unsigned int modrm;
1207 bool baseless;
1208 Elf_Internal_Sym *isym;
1209 unsigned int addend;
1210 unsigned int nop;
1211 bfd_vma nop_offset;
1212 bool is_pic;
1213 bool to_reloc_32;
1214 bool abs_symbol;
1215 unsigned int r_type;
1216 unsigned int r_symndx;
1217 bfd_vma roff = irel->r_offset;
1218 bool local_ref;
1219 struct elf_x86_link_hash_entry *eh;
1220
1221 if (roff < 2)
1222 return true;
1223
1224 /* Addend for R_386_GOT32X relocations must be 0. */
1225 addend = bfd_get_32 (abfd, contents + roff);
1226 if (addend != 0)
1227 return true;
1228
1229 htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
1230 is_pic = bfd_link_pic (link_info);
1231
1232 r_type = *r_type_p;
1233 r_symndx = ELF32_R_SYM (irel->r_info);
1234
1235 modrm = bfd_get_8 (abfd, contents + roff - 1);
1236 baseless = (modrm & 0xc7) == 0x5;
1237
1238 if (h)
1239 {
1240 /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */
1241 local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
1242 isym = NULL;
1243 abs_symbol = ABS_SYMBOL_P (h);
1244 }
1245 else
1246 {
1247 local_ref = true;
1248 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, abfd,
1249 r_symndx);
1250 abs_symbol = isym->st_shndx == SHN_ABS;
1251 }
1252
1253 if (baseless && is_pic)
1254 {
1255 /* For PIC, disallow R_386_GOT32X without a base register
1256 since we don't know what the GOT base is. */
1257 const char *name;
1258
1259 if (h == NULL)
1260 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1261 else
1262 name = h->root.root.string;
1263
1264 _bfd_error_handler
1265 /* xgettext:c-format */
1266 (_("%pB: direct GOT relocation R_386_GOT32X against `%s' without base"
1267 " register can not be used when making a shared object"),
1268 abfd, name);
1269 return false;
1270 }
1271
1272 opcode = bfd_get_8 (abfd, contents + roff - 2);
1273
1274 /* Convert to R_386_32 if PIC is false or there is no base
1275 register. */
1276 to_reloc_32 = !is_pic || baseless;
1277
1278 eh = elf_x86_hash_entry (h);
1279
1280 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1281 reloc. */
1282 if (h == NULL)
1283 {
1284 if (opcode == 0x0ff)
1285 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1286 goto convert_branch;
1287 else
1288 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1289 "test %reg1, foo@GOT(%reg2)" and
1290 "binop foo@GOT[(%reg1)], %reg2". */
1291 goto convert_load;
1292 }
1293
1294 /* Undefined weak symbol is only bound locally in executable
1295 and its reference is resolved as 0. */
1296 if (h->root.type == bfd_link_hash_undefweak
1297 && !eh->linker_def
1298 && local_ref)
1299 {
1300 if (opcode == 0xff)
1301 {
1302 /* No direct branch to 0 for PIC. */
1303 if (is_pic)
1304 return true;
1305 else
1306 goto convert_branch;
1307 }
1308 else
1309 {
1310 /* We can convert load of address 0 to R_386_32. */
1311 to_reloc_32 = true;
1312 goto convert_load;
1313 }
1314 }
1315
1316 if (opcode == 0xff)
1317 {
1318 /* We have "call/jmp *foo@GOT[(%reg)]". */
1319 if ((h->root.type == bfd_link_hash_defined
1320 || h->root.type == bfd_link_hash_defweak)
1321 && local_ref)
1322 {
1323 /* The function is locally defined. */
1324 convert_branch:
1325 /* Convert R_386_GOT32X to R_386_PC32. */
1326 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1327 {
1328 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1329 is a nop prefix. */
1330 modrm = 0xe8;
1331 /* To support TLS optimization, always use addr32 prefix
1332 for "call *___tls_get_addr@GOT(%reg)". */
1333 if (eh && eh->tls_get_addr)
1334 {
1335 nop = 0x67;
1336 nop_offset = irel->r_offset - 2;
1337 }
1338 else
1339 {
1340 nop = htab->params->call_nop_byte;
1341 if (htab->params->call_nop_as_suffix)
1342 {
1343 nop_offset = roff + 3;
1344 irel->r_offset -= 1;
1345 }
1346 else
1347 nop_offset = roff - 2;
1348 }
1349 }
1350 else
1351 {
1352 /* Convert to "jmp foo nop". */
1353 modrm = 0xe9;
1354 nop = NOP_OPCODE;
1355 nop_offset = roff + 3;
1356 irel->r_offset -= 1;
1357 }
1358
1359 bfd_put_8 (abfd, nop, contents + nop_offset);
1360 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1361 /* When converting to PC-relative relocation, we
1362 need to adjust addend by -4. */
1363 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1364 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1365 *r_type_p = R_386_PC32;
1366 *converted = true;
1367 }
1368 }
1369 else
1370 {
1371 /* We have "mov foo@GOT[(%re1g)], %reg2",
1372 "test %reg1, foo@GOT(%reg2)" and
1373 "binop foo@GOT[(%reg1)], %reg2".
1374
1375 Avoid optimizing _DYNAMIC since ld.so may use its
1376 link-time address. */
1377 if (h == htab->elf.hdynamic)
1378 return true;
1379
1380 /* def_regular is set by an assignment in a linker script in
1381 bfd_elf_record_link_assignment. start_stop is set on
1382 __start_SECNAME/__stop_SECNAME which mark section SECNAME. */
1383 if (h->start_stop
1384 || eh->linker_def
1385 || ((h->def_regular
1386 || h->root.type == bfd_link_hash_defined
1387 || h->root.type == bfd_link_hash_defweak)
1388 && local_ref))
1389 {
1390 convert_load:
1391 if (opcode == 0x8b)
1392 {
1393 if (abs_symbol && local_ref)
1394 to_reloc_32 = true;
1395
1396 if (to_reloc_32)
1397 {
1398 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1399 "mov $foo, %reg2" with R_386_32. */
1400 r_type = R_386_32;
1401 modrm = 0xc0 | (modrm & 0x38) >> 3;
1402 bfd_put_8 (abfd, modrm, contents + roff - 1);
1403 opcode = 0xc7;
1404 }
1405 else
1406 {
1407 /* Convert "mov foo@GOT(%reg1), %reg2" to
1408 "lea foo@GOTOFF(%reg1), %reg2". */
1409 r_type = R_386_GOTOFF;
1410 opcode = 0x8d;
1411 }
1412 }
1413 else
1414 {
1415 /* Only R_386_32 is supported. */
1416 if (!to_reloc_32)
1417 return true;
1418
1419 if (opcode == 0x85)
1420 {
1421 /* Convert "test %reg1, foo@GOT(%reg2)" to
1422 "test $foo, %reg1". */
1423 modrm = 0xc0 | (modrm & 0x38) >> 3;
1424 opcode = 0xf7;
1425 }
1426 else
1427 {
1428 /* Convert "binop foo@GOT(%reg1), %reg2" to
1429 "binop $foo, %reg2". */
1430 modrm = (0xc0
1431 | (modrm & 0x38) >> 3
1432 | (opcode & 0x3c));
1433 opcode = 0x81;
1434 }
1435 bfd_put_8 (abfd, modrm, contents + roff - 1);
1436 r_type = R_386_32;
1437 }
1438
1439 bfd_put_8 (abfd, opcode, contents + roff - 2);
1440 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1441 *r_type_p = r_type;
1442 *converted = true;
1443 }
1444 }
1445
1446 return true;
1447 }
1448
1449 /* Look through the relocs for a section during the first phase, and
1450 calculate needed space in the global offset table, and procedure
1451 linkage table. */
1452
1453 static bool
1454 elf_i386_scan_relocs (bfd *abfd,
1455 struct bfd_link_info *info,
1456 asection *sec,
1457 const Elf_Internal_Rela *relocs)
1458 {
1459 struct elf_x86_link_hash_table *htab;
1460 Elf_Internal_Shdr *symtab_hdr;
1461 struct elf_link_hash_entry **sym_hashes;
1462 const Elf_Internal_Rela *rel;
1463 const Elf_Internal_Rela *rel_end;
1464 bfd_byte *contents;
1465 bool converted;
1466
1467 if (bfd_link_relocatable (info))
1468 return true;
1469
1470 htab = elf_x86_hash_table (info, I386_ELF_DATA);
1471 if (htab == NULL)
1472 {
1473 sec->check_relocs_failed = 1;
1474 return false;
1475 }
1476
1477 BFD_ASSERT (is_x86_elf (abfd, htab));
1478
1479 /* Get the section contents. */
1480 if (elf_section_data (sec)->this_hdr.contents != NULL)
1481 contents = elf_section_data (sec)->this_hdr.contents;
1482 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1483 {
1484 sec->check_relocs_failed = 1;
1485 return false;
1486 }
1487
1488 symtab_hdr = &elf_symtab_hdr (abfd);
1489 sym_hashes = elf_sym_hashes (abfd);
1490
1491 converted = false;
1492
1493 rel_end = relocs + sec->reloc_count;
1494 for (rel = relocs; rel < rel_end; rel++)
1495 {
1496 unsigned int r_type;
1497 unsigned int r_symndx;
1498 struct elf_link_hash_entry *h;
1499 struct elf_x86_link_hash_entry *eh;
1500 Elf_Internal_Sym *isym;
1501 const char *name;
1502 bool size_reloc;
1503 bool no_dynreloc;
1504
1505 r_symndx = ELF32_R_SYM (rel->r_info);
1506 r_type = ELF32_R_TYPE (rel->r_info);
1507
1508 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1509 {
1510 /* xgettext:c-format */
1511 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1512 abfd, r_symndx);
1513 goto error_return;
1514 }
1515
1516 if (r_symndx < symtab_hdr->sh_info)
1517 {
1518 /* A local symbol. */
1519 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1520 abfd, r_symndx);
1521 if (isym == NULL)
1522 goto error_return;
1523
1524 /* Check relocation against local STT_GNU_IFUNC symbol. */
1525 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1526 {
1527 h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel, true);
1528 if (h == NULL)
1529 goto error_return;
1530
1531 /* Fake a STT_GNU_IFUNC symbol. */
1532 h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1533 isym, NULL);
1534 h->type = STT_GNU_IFUNC;
1535 h->def_regular = 1;
1536 h->ref_regular = 1;
1537 h->forced_local = 1;
1538 h->root.type = bfd_link_hash_defined;
1539 }
1540 else
1541 h = NULL;
1542 }
1543 else
1544 {
1545 isym = NULL;
1546 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1547 while (h->root.type == bfd_link_hash_indirect
1548 || h->root.type == bfd_link_hash_warning)
1549 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1550 }
1551
1552 eh = (struct elf_x86_link_hash_entry *) h;
1553 if (h != NULL)
1554 {
1555 if (r_type == R_386_GOTOFF)
1556 eh->gotoff_ref = 1;
1557
1558 /* It is referenced by a non-shared object. */
1559 h->ref_regular = 1;
1560 }
1561
1562 if (r_type == R_386_GOT32X
1563 && (h == NULL || h->type != STT_GNU_IFUNC))
1564 {
1565 Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
1566 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
1567 &r_type, irel, h,
1568 &converted, info))
1569 goto error_return;
1570 }
1571
1572 if (!_bfd_elf_x86_valid_reloc_p (sec, info, htab, rel, h, isym,
1573 symtab_hdr, &no_dynreloc))
1574 return false;
1575
1576 if (! elf_i386_tls_transition (info, abfd, sec, contents,
1577 symtab_hdr, sym_hashes,
1578 &r_type, GOT_UNKNOWN,
1579 rel, rel_end, h, r_symndx, false))
1580 goto error_return;
1581
1582 /* Check if _GLOBAL_OFFSET_TABLE_ is referenced. */
1583 if (h == htab->elf.hgot)
1584 htab->got_referenced = true;
1585
1586 switch (r_type)
1587 {
1588 case R_386_TLS_LDM:
1589 htab->tls_ld_or_ldm_got.refcount = 1;
1590 goto create_got;
1591
1592 case R_386_PLT32:
1593 /* This symbol requires a procedure linkage table entry. We
1594 actually build the entry in adjust_dynamic_symbol,
1595 because this might be a case of linking PIC code which is
1596 never referenced by a dynamic object, in which case we
1597 don't need to generate a procedure linkage table entry
1598 after all. */
1599
1600 /* If this is a local symbol, we resolve it directly without
1601 creating a procedure linkage table entry. */
1602 if (h == NULL)
1603 continue;
1604
1605 eh->zero_undefweak &= 0x2;
1606 h->needs_plt = 1;
1607 h->plt.refcount = 1;
1608 break;
1609
1610 case R_386_SIZE32:
1611 size_reloc = true;
1612 goto do_size;
1613
1614 case R_386_TLS_IE_32:
1615 case R_386_TLS_IE:
1616 case R_386_TLS_GOTIE:
1617 if (!bfd_link_executable (info))
1618 info->flags |= DF_STATIC_TLS;
1619 /* Fall through */
1620
1621 case R_386_GOT32:
1622 case R_386_GOT32X:
1623 case R_386_TLS_GD:
1624 case R_386_TLS_GOTDESC:
1625 case R_386_TLS_DESC_CALL:
1626 /* This symbol requires a global offset table entry. */
1627 {
1628 int tls_type, old_tls_type;
1629
1630 switch (r_type)
1631 {
1632 default:
1633 case R_386_GOT32:
1634 case R_386_GOT32X:
1635 tls_type = GOT_NORMAL;
1636 break;
1637 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1638 case R_386_TLS_GOTDESC:
1639 case R_386_TLS_DESC_CALL:
1640 tls_type = GOT_TLS_GDESC; break;
1641 case R_386_TLS_IE_32:
1642 if (ELF32_R_TYPE (rel->r_info) == r_type)
1643 tls_type = GOT_TLS_IE_NEG;
1644 else
1645 /* If this is a GD->IE transition, we may use either of
1646 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1647 tls_type = GOT_TLS_IE;
1648 break;
1649 case R_386_TLS_IE:
1650 case R_386_TLS_GOTIE:
1651 tls_type = GOT_TLS_IE_POS; break;
1652 }
1653
1654 if (h != NULL)
1655 {
1656 h->got.refcount = 1;
1657 old_tls_type = elf_x86_hash_entry (h)->tls_type;
1658 }
1659 else
1660 {
1661 bfd_signed_vma *local_got_refcounts;
1662
1663 if (!elf_x86_allocate_local_got_info (abfd,
1664 symtab_hdr->sh_info))
1665 goto error_return;
1666
1667 /* This is a global offset table entry for a local symbol. */
1668 local_got_refcounts = elf_local_got_refcounts (abfd);
1669 local_got_refcounts[r_symndx] = 1;
1670 old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx];
1671 }
1672
1673 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1674 tls_type |= old_tls_type;
1675 /* If a TLS symbol is accessed using IE at least once,
1676 there is no point to use dynamic model for it. */
1677 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1678 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1679 || (tls_type & GOT_TLS_IE) == 0))
1680 {
1681 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1682 tls_type = old_tls_type;
1683 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1684 && GOT_TLS_GD_ANY_P (tls_type))
1685 tls_type |= old_tls_type;
1686 else
1687 {
1688 if (h)
1689 name = h->root.root.string;
1690 else
1691 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1692 NULL);
1693 _bfd_error_handler
1694 /* xgettext:c-format */
1695 (_("%pB: `%s' accessed both as normal and "
1696 "thread local symbol"),
1697 abfd, name);
1698 bfd_set_error (bfd_error_bad_value);
1699 goto error_return;
1700 }
1701 }
1702
1703 if (old_tls_type != tls_type)
1704 {
1705 if (h != NULL)
1706 elf_x86_hash_entry (h)->tls_type = tls_type;
1707 else
1708 elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
1709 }
1710 }
1711 /* Fall through */
1712
1713 case R_386_GOTOFF:
1714 case R_386_GOTPC:
1715 create_got:
1716 if (r_type != R_386_TLS_IE)
1717 {
1718 if (eh != NULL)
1719 {
1720 eh->zero_undefweak &= 0x2;
1721
1722 /* Need GOT to resolve undefined weak symbol to 0. */
1723 if (r_type == R_386_GOTOFF
1724 && h->root.type == bfd_link_hash_undefweak
1725 && bfd_link_executable (info))
1726 htab->got_referenced = true;
1727 }
1728 break;
1729 }
1730 /* Fall through */
1731
1732 case R_386_TLS_LE_32:
1733 case R_386_TLS_LE:
1734 if (eh != NULL)
1735 eh->zero_undefweak &= 0x2;
1736 if (bfd_link_executable (info))
1737 break;
1738 info->flags |= DF_STATIC_TLS;
1739 goto do_relocation;
1740
1741 case R_386_32:
1742 case R_386_PC32:
1743 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
1744 eh->zero_undefweak |= 0x2;
1745 do_relocation:
1746 /* We are called after all symbols have been resolved. Only
1747 relocation against STT_GNU_IFUNC symbol must go through
1748 PLT. */
1749 if (h != NULL
1750 && (bfd_link_executable (info)
1751 || h->type == STT_GNU_IFUNC))
1752 {
1753 bool func_pointer_ref = false;
1754
1755 if (r_type == R_386_PC32)
1756 {
1757 /* Since something like ".long foo - ." may be used
1758 as pointer, make sure that PLT is used if foo is
1759 a function defined in a shared library. */
1760 if ((sec->flags & SEC_CODE) == 0)
1761 h->pointer_equality_needed = 1;
1762 else if (h->type == STT_GNU_IFUNC
1763 && bfd_link_pic (info))
1764 {
1765 _bfd_error_handler
1766 /* xgettext:c-format */
1767 (_("%pB: unsupported non-PIC call to IFUNC `%s'"),
1768 abfd, h->root.root.string);
1769 bfd_set_error (bfd_error_bad_value);
1770 goto error_return;
1771 }
1772 }
1773 else
1774 {
1775 /* R_386_32 can be resolved at run-time. Function
1776 pointer reference doesn't need PLT for pointer
1777 equality. */
1778 if (r_type == R_386_32
1779 && (sec->flags & SEC_READONLY) == 0)
1780 func_pointer_ref = true;
1781 else
1782 h->pointer_equality_needed = 1;
1783 }
1784
1785 if (!func_pointer_ref)
1786 {
1787 /* If this reloc is in a read-only section, we might
1788 need a copy reloc. We can't check reliably at this
1789 stage whether the section is read-only, as input
1790 sections have not yet been mapped to output sections.
1791 Tentatively set the flag for now, and correct in
1792 adjust_dynamic_symbol. */
1793 h->non_got_ref = 1;
1794
1795 if (!elf_has_indirect_extern_access (sec->owner))
1796 eh->non_got_ref_without_indirect_extern_access = 1;
1797
1798 /* We may need a .plt entry if the symbol is a function
1799 defined in a shared lib or is a function referenced
1800 from the code or read-only section. */
1801 if (!h->def_regular
1802 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
1803 h->plt.refcount = 1;
1804
1805 if (h->pointer_equality_needed
1806 && h->type == STT_FUNC
1807 && eh->def_protected
1808 && elf_has_indirect_extern_access (h->root.u.def.section->owner))
1809 {
1810 /* Disallow non-canonical reference to canonical
1811 protected function. */
1812 _bfd_error_handler
1813 /* xgettext:c-format */
1814 (_("%pB: non-canonical reference to canonical "
1815 "protected function `%s' in %pB"),
1816 abfd, h->root.root.string,
1817 h->root.u.def.section->owner);
1818 bfd_set_error (bfd_error_bad_value);
1819 goto error_return;
1820 }
1821 }
1822 }
1823
1824 size_reloc = false;
1825 do_size:
1826 if (!no_dynreloc
1827 && NEED_DYNAMIC_RELOCATION_P (false, info, false, h, sec,
1828 r_type, R_386_32))
1829 {
1830 struct elf_dyn_relocs *p;
1831 struct elf_dyn_relocs **head;
1832
1833 /* If this is a global symbol, we count the number of
1834 relocations we need for this symbol. */
1835 if (h != NULL)
1836 {
1837 head = &h->dyn_relocs;
1838 }
1839 else
1840 {
1841 /* Track dynamic relocs needed for local syms too.
1842 We really need local syms available to do this
1843 easily. Oh well. */
1844 void **vpp;
1845 asection *s;
1846
1847 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1848 abfd, r_symndx);
1849 if (isym == NULL)
1850 goto error_return;
1851
1852 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1853 if (s == NULL)
1854 s = sec;
1855
1856 vpp = &elf_section_data (s)->local_dynrel;
1857 head = (struct elf_dyn_relocs **)vpp;
1858 }
1859
1860 p = *head;
1861 if (p == NULL || p->sec != sec)
1862 {
1863 size_t amt = sizeof *p;
1864 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1865 amt);
1866 if (p == NULL)
1867 goto error_return;
1868 p->next = *head;
1869 *head = p;
1870 p->sec = sec;
1871 p->count = 0;
1872 p->pc_count = 0;
1873 }
1874
1875 p->count += 1;
1876 /* Count size relocation as PC-relative relocation. */
1877 if (r_type == R_386_PC32 || size_reloc)
1878 p->pc_count += 1;
1879 }
1880 break;
1881
1882 /* This relocation describes the C++ object vtable hierarchy.
1883 Reconstruct it for later use during GC. */
1884 case R_386_GNU_VTINHERIT:
1885 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1886 goto error_return;
1887 break;
1888
1889 /* This relocation describes which C++ vtable entries are actually
1890 used. Record for later use during GC. */
1891 case R_386_GNU_VTENTRY:
1892 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1893 goto error_return;
1894 break;
1895
1896 default:
1897 break;
1898 }
1899 }
1900
1901 if (elf_section_data (sec)->this_hdr.contents != contents)
1902 {
1903 if (!converted && !_bfd_link_keep_memory (info))
1904 free (contents);
1905 else
1906 {
1907 /* Cache the section contents for elf_link_input_bfd if any
1908 load is converted or --no-keep-memory isn't used. */
1909 elf_section_data (sec)->this_hdr.contents = contents;
1910 info->cache_size += sec->size;
1911 }
1912 }
1913
1914 /* Cache relocations if any load is converted. */
1915 if (elf_section_data (sec)->relocs != relocs && converted)
1916 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
1917
1918 return true;
1919
1920 error_return:
1921 if (elf_section_data (sec)->this_hdr.contents != contents)
1922 free (contents);
1923 sec->check_relocs_failed = 1;
1924 return false;
1925 }
1926
1927 static bool
1928 elf_i386_always_size_sections (bfd *output_bfd,
1929 struct bfd_link_info *info)
1930 {
1931 bfd *abfd;
1932
1933 /* Scan relocations after rel_from_abs has been set on __ehdr_start. */
1934 for (abfd = info->input_bfds;
1935 abfd != (bfd *) NULL;
1936 abfd = abfd->link.next)
1937 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1938 && !_bfd_elf_link_iterate_on_relocs (abfd, info,
1939 elf_i386_scan_relocs))
1940 return false;
1941
1942 return _bfd_x86_elf_always_size_sections (output_bfd, info);
1943 }
1944
1945 /* Set the correct type for an x86 ELF section. We do this by the
1946 section name, which is a hack, but ought to work. */
1947
1948 static bool
1949 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1950 Elf_Internal_Shdr *hdr,
1951 asection *sec)
1952 {
1953 const char *name;
1954
1955 name = bfd_section_name (sec);
1956
1957 /* This is an ugly, but unfortunately necessary hack that is
1958 needed when producing EFI binaries on x86. It tells
1959 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1960 containing ELF relocation info. We need this hack in order to
1961 be able to generate ELF binaries that can be translated into
1962 EFI applications (which are essentially COFF objects). Those
1963 files contain a COFF ".reloc" section inside an ELFNN object,
1964 which would normally cause BFD to segfault because it would
1965 attempt to interpret this section as containing relocation
1966 entries for section "oc". With this hack enabled, ".reloc"
1967 will be treated as a normal data section, which will avoid the
1968 segfault. However, you won't be able to create an ELFNN binary
1969 with a section named "oc" that needs relocations, but that's
1970 the kind of ugly side-effects you get when detecting section
1971 types based on their names... In practice, this limitation is
1972 unlikely to bite. */
1973 if (strcmp (name, ".reloc") == 0)
1974 hdr->sh_type = SHT_PROGBITS;
1975
1976 return true;
1977 }
1978
1979 /* Return the relocation value for @tpoff relocation
1980 if STT_TLS virtual address is ADDRESS. */
1981
1982 static bfd_vma
1983 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
1984 {
1985 struct elf_link_hash_table *htab = elf_hash_table (info);
1986 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
1987 bfd_vma static_tls_size;
1988
1989 /* If tls_sec is NULL, we should have signalled an error already. */
1990 if (htab->tls_sec == NULL)
1991 return 0;
1992
1993 /* Consider special static TLS alignment requirements. */
1994 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
1995 return static_tls_size + htab->tls_sec->vma - address;
1996 }
1997
1998 /* Relocate an i386 ELF section. */
1999
2000 static int
2001 elf_i386_relocate_section (bfd *output_bfd,
2002 struct bfd_link_info *info,
2003 bfd *input_bfd,
2004 asection *input_section,
2005 bfd_byte *contents,
2006 Elf_Internal_Rela *relocs,
2007 Elf_Internal_Sym *local_syms,
2008 asection **local_sections)
2009 {
2010 struct elf_x86_link_hash_table *htab;
2011 Elf_Internal_Shdr *symtab_hdr;
2012 struct elf_link_hash_entry **sym_hashes;
2013 bfd_vma *local_got_offsets;
2014 bfd_vma *local_tlsdesc_gotents;
2015 Elf_Internal_Rela *rel;
2016 Elf_Internal_Rela *wrel;
2017 Elf_Internal_Rela *relend;
2018 bool is_vxworks_tls;
2019 unsigned plt_entry_size;
2020
2021 /* Skip if check_relocs or scan_relocs failed. */
2022 if (input_section->check_relocs_failed)
2023 return false;
2024
2025 htab = elf_x86_hash_table (info, I386_ELF_DATA);
2026 if (htab == NULL)
2027 return false;
2028
2029 if (!is_x86_elf (input_bfd, htab))
2030 {
2031 bfd_set_error (bfd_error_wrong_format);
2032 return false;
2033 }
2034
2035 symtab_hdr = &elf_symtab_hdr (input_bfd);
2036 sym_hashes = elf_sym_hashes (input_bfd);
2037 local_got_offsets = elf_local_got_offsets (input_bfd);
2038 local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2039 /* We have to handle relocations in vxworks .tls_vars sections
2040 specially, because the dynamic loader is 'weird'. */
2041 is_vxworks_tls = (htab->elf.target_os == is_vxworks
2042 && bfd_link_pic (info)
2043 && !strcmp (input_section->output_section->name,
2044 ".tls_vars"));
2045
2046 _bfd_x86_elf_set_tls_module_base (info);
2047
2048 plt_entry_size = htab->plt.plt_entry_size;
2049
2050 rel = wrel = relocs;
2051 relend = relocs + input_section->reloc_count;
2052 for (; rel < relend; wrel++, rel++)
2053 {
2054 unsigned int r_type, r_type_tls;
2055 reloc_howto_type *howto;
2056 unsigned long r_symndx;
2057 struct elf_link_hash_entry *h;
2058 struct elf_x86_link_hash_entry *eh;
2059 Elf_Internal_Sym *sym;
2060 asection *sec;
2061 bfd_vma off, offplt, plt_offset;
2062 bfd_vma relocation;
2063 bool unresolved_reloc;
2064 bfd_reloc_status_type r;
2065 unsigned int indx;
2066 int tls_type;
2067 bfd_vma st_size;
2068 asection *resolved_plt;
2069 bool resolved_to_zero;
2070 bool relative_reloc;
2071
2072 r_type = ELF32_R_TYPE (rel->r_info);
2073 if (r_type == R_386_GNU_VTINHERIT
2074 || r_type == R_386_GNU_VTENTRY)
2075 {
2076 if (wrel != rel)
2077 *wrel = *rel;
2078 continue;
2079 }
2080
2081 howto = elf_i386_rtype_to_howto (r_type);
2082 if (howto == NULL)
2083 return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2084
2085 r_symndx = ELF32_R_SYM (rel->r_info);
2086 h = NULL;
2087 sym = NULL;
2088 sec = NULL;
2089 unresolved_reloc = false;
2090 if (r_symndx < symtab_hdr->sh_info)
2091 {
2092 sym = local_syms + r_symndx;
2093 sec = local_sections[r_symndx];
2094 relocation = (sec->output_section->vma
2095 + sec->output_offset
2096 + sym->st_value);
2097 st_size = sym->st_size;
2098
2099 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2100 && ((sec->flags & SEC_MERGE) != 0
2101 || (bfd_link_relocatable (info)
2102 && sec->output_offset != 0)))
2103 {
2104 bfd_vma addend;
2105 bfd_byte *where = contents + rel->r_offset;
2106
2107 switch (howto->size)
2108 {
2109 case 0:
2110 addend = bfd_get_8 (input_bfd, where);
2111 if (howto->pc_relative)
2112 {
2113 addend = (addend ^ 0x80) - 0x80;
2114 addend += 1;
2115 }
2116 break;
2117 case 1:
2118 addend = bfd_get_16 (input_bfd, where);
2119 if (howto->pc_relative)
2120 {
2121 addend = (addend ^ 0x8000) - 0x8000;
2122 addend += 2;
2123 }
2124 break;
2125 case 2:
2126 addend = bfd_get_32 (input_bfd, where);
2127 if (howto->pc_relative)
2128 {
2129 addend = (addend ^ 0x80000000) - 0x80000000;
2130 addend += 4;
2131 }
2132 break;
2133 default:
2134 abort ();
2135 }
2136
2137 if (bfd_link_relocatable (info))
2138 addend += sec->output_offset;
2139 else
2140 {
2141 asection *msec = sec;
2142 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2143 addend);
2144 addend -= relocation;
2145 addend += msec->output_section->vma + msec->output_offset;
2146 }
2147
2148 switch (howto->size)
2149 {
2150 case 0:
2151 /* FIXME: overflow checks. */
2152 if (howto->pc_relative)
2153 addend -= 1;
2154 bfd_put_8 (input_bfd, addend, where);
2155 break;
2156 case 1:
2157 if (howto->pc_relative)
2158 addend -= 2;
2159 bfd_put_16 (input_bfd, addend, where);
2160 break;
2161 case 2:
2162 if (howto->pc_relative)
2163 addend -= 4;
2164 bfd_put_32 (input_bfd, addend, where);
2165 break;
2166 }
2167 }
2168 else if (!bfd_link_relocatable (info)
2169 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2170 {
2171 /* Relocate against local STT_GNU_IFUNC symbol. */
2172 h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd, rel,
2173 false);
2174 if (h == NULL)
2175 abort ();
2176
2177 /* Set STT_GNU_IFUNC symbol value. */
2178 h->root.u.def.value = sym->st_value;
2179 h->root.u.def.section = sec;
2180 }
2181 }
2182 else
2183 {
2184 bool warned ATTRIBUTE_UNUSED;
2185 bool ignored ATTRIBUTE_UNUSED;
2186
2187 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2188 r_symndx, symtab_hdr, sym_hashes,
2189 h, sec, relocation,
2190 unresolved_reloc, warned, ignored);
2191 st_size = h->size;
2192 }
2193
2194 if (sec != NULL && discarded_section (sec))
2195 {
2196 _bfd_clear_contents (howto, input_bfd, input_section,
2197 contents, rel->r_offset);
2198 wrel->r_offset = rel->r_offset;
2199 wrel->r_info = 0;
2200 wrel->r_addend = 0;
2201
2202 /* For ld -r, remove relocations in debug sections against
2203 sections defined in discarded sections. Not done for
2204 eh_frame editing code expects to be present. */
2205 if (bfd_link_relocatable (info)
2206 && (input_section->flags & SEC_DEBUGGING))
2207 wrel--;
2208
2209 continue;
2210 }
2211
2212 if (bfd_link_relocatable (info))
2213 {
2214 if (wrel != rel)
2215 *wrel = *rel;
2216 continue;
2217 }
2218
2219 eh = (struct elf_x86_link_hash_entry *) h;
2220
2221 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2222 it here if it is defined in a non-shared object. */
2223 if (h != NULL
2224 && h->type == STT_GNU_IFUNC
2225 && h->def_regular)
2226 {
2227 asection *gotplt, *base_got;
2228 bfd_vma plt_index;
2229 const char *name;
2230
2231 if ((input_section->flags & SEC_ALLOC) == 0)
2232 {
2233 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2234 STT_GNU_IFUNC symbol as STT_FUNC. */
2235 if (elf_section_type (input_section) == SHT_NOTE)
2236 goto skip_ifunc;
2237 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2238 sections because such sections are not SEC_ALLOC and
2239 thus ld.so will not process them. */
2240 if ((input_section->flags & SEC_DEBUGGING) != 0)
2241 continue;
2242 abort ();
2243 }
2244
2245 /* STT_GNU_IFUNC symbol must go through PLT. */
2246 if (htab->elf.splt != NULL)
2247 {
2248 if (htab->plt_second != NULL)
2249 {
2250 resolved_plt = htab->plt_second;
2251 plt_offset = eh->plt_second.offset;
2252 }
2253 else
2254 {
2255 resolved_plt = htab->elf.splt;
2256 plt_offset = h->plt.offset;
2257 }
2258 gotplt = htab->elf.sgotplt;
2259 }
2260 else
2261 {
2262 resolved_plt = htab->elf.iplt;
2263 plt_offset = h->plt.offset;
2264 gotplt = htab->elf.igotplt;
2265 }
2266
2267 switch (r_type)
2268 {
2269 default:
2270 break;
2271
2272 case R_386_GOT32:
2273 case R_386_GOT32X:
2274 base_got = htab->elf.sgot;
2275 off = h->got.offset;
2276
2277 if (base_got == NULL)
2278 abort ();
2279
2280 if (off == (bfd_vma) -1)
2281 {
2282 /* We can't use h->got.offset here to save state, or
2283 even just remember the offset, as finish_dynamic_symbol
2284 would use that as offset into .got. */
2285
2286 if (h->plt.offset == (bfd_vma) -1)
2287 abort ();
2288
2289 if (htab->elf.splt != NULL)
2290 {
2291 plt_index = (h->plt.offset / plt_entry_size
2292 - htab->plt.has_plt0);
2293 off = (plt_index + 3) * 4;
2294 base_got = htab->elf.sgotplt;
2295 }
2296 else
2297 {
2298 plt_index = h->plt.offset / plt_entry_size;
2299 off = plt_index * 4;
2300 base_got = htab->elf.igotplt;
2301 }
2302
2303 if (h->dynindx == -1
2304 || h->forced_local
2305 || info->symbolic)
2306 {
2307 /* This references the local defitionion. We must
2308 initialize this entry in the global offset table.
2309 Since the offset must always be a multiple of 4,
2310 we use the least significant bit to record
2311 whether we have initialized it already.
2312
2313 When doing a dynamic link, we create a .rela.got
2314 relocation entry to initialize the value. This
2315 is done in the finish_dynamic_symbol routine. */
2316 if ((off & 1) != 0)
2317 off &= ~1;
2318 else
2319 {
2320 bfd_put_32 (output_bfd, relocation,
2321 base_got->contents + off);
2322 h->got.offset |= 1;
2323 }
2324 }
2325
2326 relocation = off;
2327 }
2328 else
2329 relocation = (base_got->output_section->vma
2330 + base_got->output_offset + off
2331 - gotplt->output_section->vma
2332 - gotplt->output_offset);
2333
2334 if (rel->r_offset > 1
2335 && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2336 && *(contents + rel->r_offset - 2) != 0x8d)
2337 {
2338 if (bfd_link_pic (info))
2339 goto disallow_got32;
2340
2341 /* Add the GOT base if there is no base register. */
2342 relocation += (gotplt->output_section->vma
2343 + gotplt->output_offset);
2344 }
2345 else if (htab->elf.splt == NULL)
2346 {
2347 /* Adjust for static executables. */
2348 relocation += gotplt->output_offset;
2349 }
2350
2351 goto do_relocation;
2352 }
2353
2354 if (h->plt.offset == (bfd_vma) -1)
2355 {
2356 /* Handle static pointers of STT_GNU_IFUNC symbols. */
2357 if (r_type == R_386_32
2358 && (input_section->flags & SEC_CODE) == 0)
2359 goto do_ifunc_pointer;
2360 goto bad_ifunc_reloc;
2361 }
2362
2363 relocation = (resolved_plt->output_section->vma
2364 + resolved_plt->output_offset + plt_offset);
2365
2366 switch (r_type)
2367 {
2368 default:
2369 bad_ifunc_reloc:
2370 if (h->root.root.string)
2371 name = h->root.root.string;
2372 else
2373 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2374 NULL);
2375 _bfd_error_handler
2376 /* xgettext:c-format */
2377 (_("%pB: relocation %s against STT_GNU_IFUNC "
2378 "symbol `%s' isn't supported"), input_bfd,
2379 howto->name, name);
2380 bfd_set_error (bfd_error_bad_value);
2381 return false;
2382
2383 case R_386_32:
2384 /* Generate dynamic relcoation only when there is a
2385 non-GOT reference in a shared object. */
2386 if ((bfd_link_pic (info) && h->non_got_ref)
2387 || h->plt.offset == (bfd_vma) -1)
2388 {
2389 Elf_Internal_Rela outrel;
2390 asection *sreloc;
2391 bfd_vma offset;
2392
2393 do_ifunc_pointer:
2394 /* Need a dynamic relocation to get the real function
2395 adddress. */
2396 offset = _bfd_elf_section_offset (output_bfd,
2397 info,
2398 input_section,
2399 rel->r_offset);
2400 if (offset == (bfd_vma) -1
2401 || offset == (bfd_vma) -2)
2402 abort ();
2403
2404 outrel.r_offset = (input_section->output_section->vma
2405 + input_section->output_offset
2406 + offset);
2407
2408 if (POINTER_LOCAL_IFUNC_P (info, h))
2409 {
2410 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
2411 h->root.root.string,
2412 h->root.u.def.section->owner);
2413
2414 /* This symbol is resolved locally. */
2415 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
2416
2417 if (htab->params->report_relative_reloc)
2418 _bfd_x86_elf_link_report_relative_reloc
2419 (info, input_section, h, sym,
2420 "R_386_IRELATIVE", &outrel);
2421
2422 bfd_put_32 (output_bfd,
2423 (h->root.u.def.value
2424 + h->root.u.def.section->output_section->vma
2425 + h->root.u.def.section->output_offset),
2426 contents + offset);
2427 }
2428 else
2429 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2430
2431 /* Dynamic relocations are stored in
2432 1. .rel.ifunc section in PIC object.
2433 2. .rel.got section in dynamic executable.
2434 3. .rel.iplt section in static executable. */
2435 if (bfd_link_pic (info))
2436 sreloc = htab->elf.irelifunc;
2437 else if (htab->elf.splt != NULL)
2438 sreloc = htab->elf.srelgot;
2439 else
2440 sreloc = htab->elf.irelplt;
2441 elf_append_rel (output_bfd, sreloc, &outrel);
2442
2443 /* If this reloc is against an external symbol, we
2444 do not want to fiddle with the addend. Otherwise,
2445 we need to include the symbol value so that it
2446 becomes an addend for the dynamic reloc. For an
2447 internal symbol, we have updated addend. */
2448 continue;
2449 }
2450 /* FALLTHROUGH */
2451 case R_386_PC32:
2452 case R_386_PLT32:
2453 goto do_relocation;
2454
2455 case R_386_GOTOFF:
2456 relocation -= (gotplt->output_section->vma
2457 + gotplt->output_offset);
2458 goto do_relocation;
2459 }
2460 }
2461
2462 skip_ifunc:
2463 resolved_to_zero = (eh != NULL
2464 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2465
2466 switch (r_type)
2467 {
2468 case R_386_GOT32X:
2469 case R_386_GOT32:
2470 /* Relocation is to the entry for this symbol in the global
2471 offset table. */
2472 if (htab->elf.sgot == NULL)
2473 abort ();
2474
2475 relative_reloc = false;
2476 if (h != NULL)
2477 {
2478 off = h->got.offset;
2479 if (RESOLVED_LOCALLY_P (info, h, htab))
2480 {
2481 /* We must initialize this entry in the global offset
2482 table. Since the offset must always be a multiple
2483 of 4, we use the least significant bit to record
2484 whether we have initialized it already.
2485
2486 When doing a dynamic link, we create a .rel.got
2487 relocation entry to initialize the value. This
2488 is done in the finish_dynamic_symbol routine. */
2489 if ((off & 1) != 0)
2490 off &= ~1;
2491 else
2492 {
2493 bfd_put_32 (output_bfd, relocation,
2494 htab->elf.sgot->contents + off);
2495 h->got.offset |= 1;
2496 /* NB: Don't generate relative relocation here if
2497 it has been generated by DT_RELR. */
2498 if (!info->enable_dt_relr
2499 && GENERATE_RELATIVE_RELOC_P (info, h))
2500 {
2501 /* PR ld/21402: If this symbol isn't dynamic
2502 in PIC, generate R_386_RELATIVE here. */
2503 eh->no_finish_dynamic_symbol = 1;
2504 relative_reloc = true;
2505 }
2506 }
2507 }
2508 else
2509 unresolved_reloc = false;
2510 }
2511 else
2512 {
2513 if (local_got_offsets == NULL)
2514 abort ();
2515
2516 off = local_got_offsets[r_symndx];
2517
2518 /* The offset must always be a multiple of 4. We use
2519 the least significant bit to record whether we have
2520 already generated the necessary reloc. */
2521 if ((off & 1) != 0)
2522 off &= ~1;
2523 else
2524 {
2525 bfd_put_32 (output_bfd, relocation,
2526 htab->elf.sgot->contents + off);
2527 local_got_offsets[r_symndx] |= 1;
2528
2529 /* NB: Don't generate relative relocation here if it
2530 has been generated by DT_RELR. */
2531 if (!info->enable_dt_relr && bfd_link_pic (info))
2532 relative_reloc = true;
2533 }
2534 }
2535
2536 if (relative_reloc)
2537 {
2538 asection *s;
2539 Elf_Internal_Rela outrel;
2540
2541 s = htab->elf.srelgot;
2542 if (s == NULL)
2543 abort ();
2544
2545 outrel.r_offset = (htab->elf.sgot->output_section->vma
2546 + htab->elf.sgot->output_offset
2547 + off);
2548 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2549
2550 if (htab->params->report_relative_reloc)
2551 _bfd_x86_elf_link_report_relative_reloc
2552 (info, input_section, h, sym, "R_386_RELATIVE",
2553 &outrel);
2554
2555 elf_append_rel (output_bfd, s, &outrel);
2556 }
2557
2558 if (off >= (bfd_vma) -2)
2559 abort ();
2560
2561 relocation = (htab->elf.sgot->output_section->vma
2562 + htab->elf.sgot->output_offset + off);
2563 if (rel->r_offset > 1
2564 && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2565 && *(contents + rel->r_offset - 2) != 0x8d)
2566 {
2567 if (bfd_link_pic (info))
2568 {
2569 /* For PIC, disallow R_386_GOT32 without a base
2570 register, except for "lea foo@GOT, %reg", since
2571 we don't know what the GOT base is. */
2572 const char *name;
2573
2574 disallow_got32:
2575 if (h == NULL || h->root.root.string == NULL)
2576 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2577 NULL);
2578 else
2579 name = h->root.root.string;
2580
2581 _bfd_error_handler
2582 /* xgettext:c-format */
2583 (_("%pB: direct GOT relocation %s against `%s'"
2584 " without base register can not be used"
2585 " when making a shared object"),
2586 input_bfd, howto->name, name);
2587 bfd_set_error (bfd_error_bad_value);
2588 return false;
2589 }
2590 }
2591 else
2592 {
2593 /* Subtract the .got.plt section address only with a base
2594 register. */
2595 relocation -= (htab->elf.sgotplt->output_section->vma
2596 + htab->elf.sgotplt->output_offset);
2597 }
2598
2599 break;
2600
2601 case R_386_GOTOFF:
2602 /* Relocation is relative to the start of the global offset
2603 table. */
2604
2605 /* Check to make sure it isn't a protected function or data
2606 symbol for shared library since it may not be local when
2607 used as function address or with copy relocation. We also
2608 need to make sure that a symbol is referenced locally. */
2609 if (!bfd_link_executable (info) && h)
2610 {
2611 if (!h->def_regular)
2612 {
2613 const char *v;
2614
2615 switch (ELF_ST_VISIBILITY (h->other))
2616 {
2617 case STV_HIDDEN:
2618 v = _("hidden symbol");
2619 break;
2620 case STV_INTERNAL:
2621 v = _("internal symbol");
2622 break;
2623 case STV_PROTECTED:
2624 v = _("protected symbol");
2625 break;
2626 default:
2627 v = _("symbol");
2628 break;
2629 }
2630
2631 _bfd_error_handler
2632 /* xgettext:c-format */
2633 (_("%pB: relocation R_386_GOTOFF against undefined %s"
2634 " `%s' can not be used when making a shared object"),
2635 input_bfd, v, h->root.root.string);
2636 bfd_set_error (bfd_error_bad_value);
2637 return false;
2638 }
2639 else if (!SYMBOL_REFERENCES_LOCAL_P (info, h)
2640 && (h->type == STT_FUNC
2641 || h->type == STT_OBJECT)
2642 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2643 {
2644 _bfd_error_handler
2645 /* xgettext:c-format */
2646 (_("%pB: relocation R_386_GOTOFF against protected %s"
2647 " `%s' can not be used when making a shared object"),
2648 input_bfd,
2649 h->type == STT_FUNC ? "function" : "data",
2650 h->root.root.string);
2651 bfd_set_error (bfd_error_bad_value);
2652 return false;
2653 }
2654 }
2655
2656 /* Note that sgot is not involved in this
2657 calculation. We always want the start of .got.plt. If we
2658 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2659 permitted by the ABI, we might have to change this
2660 calculation. */
2661 relocation -= htab->elf.sgotplt->output_section->vma
2662 + htab->elf.sgotplt->output_offset;
2663 break;
2664
2665 case R_386_GOTPC:
2666 /* Use global offset table as symbol value. */
2667 relocation = htab->elf.sgotplt->output_section->vma
2668 + htab->elf.sgotplt->output_offset;
2669 unresolved_reloc = false;
2670 break;
2671
2672 case R_386_PLT32:
2673 /* Relocation is to the entry for this symbol in the
2674 procedure linkage table. */
2675
2676 /* Resolve a PLT32 reloc against a local symbol directly,
2677 without using the procedure linkage table. */
2678 if (h == NULL)
2679 break;
2680
2681 if ((h->plt.offset == (bfd_vma) -1
2682 && eh->plt_got.offset == (bfd_vma) -1)
2683 || htab->elf.splt == NULL)
2684 {
2685 /* We didn't make a PLT entry for this symbol. This
2686 happens when statically linking PIC code, or when
2687 using -Bsymbolic. */
2688 break;
2689 }
2690
2691 if (h->plt.offset != (bfd_vma) -1)
2692 {
2693 if (htab->plt_second != NULL)
2694 {
2695 resolved_plt = htab->plt_second;
2696 plt_offset = eh->plt_second.offset;
2697 }
2698 else
2699 {
2700 resolved_plt = htab->elf.splt;
2701 plt_offset = h->plt.offset;
2702 }
2703 }
2704 else
2705 {
2706 resolved_plt = htab->plt_got;
2707 plt_offset = eh->plt_got.offset;
2708 }
2709
2710 relocation = (resolved_plt->output_section->vma
2711 + resolved_plt->output_offset
2712 + plt_offset);
2713 unresolved_reloc = false;
2714 break;
2715
2716 case R_386_SIZE32:
2717 /* Set to symbol size. */
2718 relocation = st_size;
2719 /* Fall through. */
2720
2721 case R_386_32:
2722 case R_386_PC32:
2723 if ((input_section->flags & SEC_ALLOC) == 0
2724 || is_vxworks_tls)
2725 break;
2726
2727 if (GENERATE_DYNAMIC_RELOCATION_P (false, info, eh, r_type,
2728 sec, false,
2729 resolved_to_zero,
2730 (r_type == R_386_PC32)))
2731 {
2732 Elf_Internal_Rela outrel;
2733 bool skip, relocate;
2734 bool generate_dynamic_reloc = true;
2735 asection *sreloc;
2736
2737 /* When generating a shared object, these relocations
2738 are copied into the output file to be resolved at run
2739 time. */
2740
2741 skip = false;
2742 relocate = false;
2743
2744 outrel.r_offset =
2745 _bfd_elf_section_offset (output_bfd, info, input_section,
2746 rel->r_offset);
2747 if (outrel.r_offset == (bfd_vma) -1)
2748 skip = true;
2749 else if (outrel.r_offset == (bfd_vma) -2)
2750 skip = true, relocate = true;
2751 outrel.r_offset += (input_section->output_section->vma
2752 + input_section->output_offset);
2753
2754 if (skip)
2755 memset (&outrel, 0, sizeof outrel);
2756 else if (COPY_INPUT_RELOC_P (false, info, h, r_type))
2757 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2758 else
2759 {
2760 /* This symbol is local, or marked to become local. */
2761 relocate = true;
2762 /* NB: Don't generate relative relocation here if it
2763 has been generated by DT_RELR. */
2764 if (info->enable_dt_relr)
2765 generate_dynamic_reloc = false;
2766 else
2767 {
2768 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2769
2770 if (htab->params->report_relative_reloc)
2771 _bfd_x86_elf_link_report_relative_reloc
2772 (info, input_section, h, sym, "R_386_RELATIVE",
2773 &outrel);
2774 }
2775 }
2776
2777 if (generate_dynamic_reloc)
2778 {
2779 sreloc = elf_section_data (input_section)->sreloc;
2780
2781 if (sreloc == NULL || sreloc->contents == NULL)
2782 {
2783 r = bfd_reloc_notsupported;
2784 goto check_relocation_error;
2785 }
2786
2787 elf_append_rel (output_bfd, sreloc, &outrel);
2788 }
2789
2790 /* If this reloc is against an external symbol, we do
2791 not want to fiddle with the addend. Otherwise, we
2792 need to include the symbol value so that it becomes
2793 an addend for the dynamic reloc. */
2794 if (! relocate)
2795 continue;
2796 }
2797 break;
2798
2799 case R_386_TLS_IE:
2800 if (!bfd_link_executable (info))
2801 {
2802 Elf_Internal_Rela outrel;
2803 asection *sreloc;
2804
2805 outrel.r_offset = rel->r_offset
2806 + input_section->output_section->vma
2807 + input_section->output_offset;
2808 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2809
2810 if (htab->params->report_relative_reloc)
2811 _bfd_x86_elf_link_report_relative_reloc
2812 (info, input_section, h, sym, "R_386_RELATIVE",
2813 &outrel);
2814
2815 sreloc = elf_section_data (input_section)->sreloc;
2816 if (sreloc == NULL)
2817 abort ();
2818 elf_append_rel (output_bfd, sreloc, &outrel);
2819 }
2820 /* Fall through */
2821
2822 case R_386_TLS_GD:
2823 case R_386_TLS_GOTDESC:
2824 case R_386_TLS_DESC_CALL:
2825 case R_386_TLS_IE_32:
2826 case R_386_TLS_GOTIE:
2827 tls_type = GOT_UNKNOWN;
2828 if (h == NULL && local_got_offsets)
2829 tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
2830 else if (h != NULL)
2831 tls_type = elf_x86_hash_entry(h)->tls_type;
2832 if (tls_type == GOT_TLS_IE)
2833 tls_type = GOT_TLS_IE_NEG;
2834
2835 r_type_tls = r_type;
2836 if (! elf_i386_tls_transition (info, input_bfd,
2837 input_section, contents,
2838 symtab_hdr, sym_hashes,
2839 &r_type_tls, tls_type, rel,
2840 relend, h, r_symndx, true))
2841 return false;
2842
2843 if (r_type_tls == R_386_TLS_LE_32)
2844 {
2845 BFD_ASSERT (! unresolved_reloc);
2846 if (r_type == R_386_TLS_GD)
2847 {
2848 unsigned int type;
2849 bfd_vma roff;
2850
2851 /* GD->LE transition. */
2852 type = *(contents + rel->r_offset - 2);
2853 if (type == 0x04)
2854 {
2855 /* Change
2856 leal foo@tlsgd(,%ebx,1), %eax
2857 call ___tls_get_addr@PLT
2858 into:
2859 movl %gs:0, %eax
2860 subl $foo@tpoff, %eax
2861 (6 byte form of subl). */
2862 roff = rel->r_offset + 5;
2863 }
2864 else
2865 {
2866 /* Change
2867 leal foo@tlsgd(%ebx), %eax
2868 call ___tls_get_addr@PLT
2869 nop
2870 or
2871 leal foo@tlsgd(%reg), %eax
2872 call *___tls_get_addr@GOT(%reg)
2873 which may be converted to
2874 addr32 call ___tls_get_addr
2875 into:
2876 movl %gs:0, %eax; subl $foo@tpoff, %eax
2877 (6 byte form of subl). */
2878 roff = rel->r_offset + 6;
2879 }
2880 memcpy (contents + roff - 8,
2881 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2882 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
2883 contents + roff);
2884 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
2885 rel++;
2886 wrel++;
2887 continue;
2888 }
2889 else if (r_type == R_386_TLS_GOTDESC)
2890 {
2891 /* GDesc -> LE transition.
2892 It's originally something like:
2893 leal x@tlsdesc(%ebx), %eax
2894
2895 leal x@ntpoff, %eax
2896
2897 Registers other than %eax may be set up here. */
2898
2899 unsigned int val;
2900 bfd_vma roff;
2901
2902 roff = rel->r_offset;
2903 val = bfd_get_8 (input_bfd, contents + roff - 1);
2904
2905 /* Now modify the instruction as appropriate. */
2906 /* aoliva FIXME: remove the above and xor the byte
2907 below with 0x86. */
2908 bfd_put_8 (output_bfd, val ^ 0x86,
2909 contents + roff - 1);
2910 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2911 contents + roff);
2912 continue;
2913 }
2914 else if (r_type == R_386_TLS_DESC_CALL)
2915 {
2916 /* GDesc -> LE transition.
2917 It's originally:
2918 call *(%eax)
2919 Turn it into:
2920 xchg %ax,%ax */
2921
2922 bfd_vma roff;
2923
2924 roff = rel->r_offset;
2925 bfd_put_8 (output_bfd, 0x66, contents + roff);
2926 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2927 continue;
2928 }
2929 else if (r_type == R_386_TLS_IE)
2930 {
2931 unsigned int val;
2932
2933 /* IE->LE transition:
2934 Originally it can be one of:
2935 movl foo, %eax
2936 movl foo, %reg
2937 addl foo, %reg
2938 We change it into:
2939 movl $foo, %eax
2940 movl $foo, %reg
2941 addl $foo, %reg. */
2942 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2943 if (val == 0xa1)
2944 {
2945 /* movl foo, %eax. */
2946 bfd_put_8 (output_bfd, 0xb8,
2947 contents + rel->r_offset - 1);
2948 }
2949 else
2950 {
2951 unsigned int type;
2952
2953 type = bfd_get_8 (input_bfd,
2954 contents + rel->r_offset - 2);
2955 switch (type)
2956 {
2957 case 0x8b:
2958 /* movl */
2959 bfd_put_8 (output_bfd, 0xc7,
2960 contents + rel->r_offset - 2);
2961 bfd_put_8 (output_bfd,
2962 0xc0 | ((val >> 3) & 7),
2963 contents + rel->r_offset - 1);
2964 break;
2965 case 0x03:
2966 /* addl */
2967 bfd_put_8 (output_bfd, 0x81,
2968 contents + rel->r_offset - 2);
2969 bfd_put_8 (output_bfd,
2970 0xc0 | ((val >> 3) & 7),
2971 contents + rel->r_offset - 1);
2972 break;
2973 default:
2974 BFD_FAIL ();
2975 break;
2976 }
2977 }
2978 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2979 contents + rel->r_offset);
2980 continue;
2981 }
2982 else
2983 {
2984 unsigned int val, type;
2985
2986 /* {IE_32,GOTIE}->LE transition:
2987 Originally it can be one of:
2988 subl foo(%reg1), %reg2
2989 movl foo(%reg1), %reg2
2990 addl foo(%reg1), %reg2
2991 We change it into:
2992 subl $foo, %reg2
2993 movl $foo, %reg2 (6 byte form)
2994 addl $foo, %reg2. */
2995 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2996 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2997 if (type == 0x8b)
2998 {
2999 /* movl */
3000 bfd_put_8 (output_bfd, 0xc7,
3001 contents + rel->r_offset - 2);
3002 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3003 contents + rel->r_offset - 1);
3004 }
3005 else if (type == 0x2b)
3006 {
3007 /* subl */
3008 bfd_put_8 (output_bfd, 0x81,
3009 contents + rel->r_offset - 2);
3010 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3011 contents + rel->r_offset - 1);
3012 }
3013 else if (type == 0x03)
3014 {
3015 /* addl */
3016 bfd_put_8 (output_bfd, 0x81,
3017 contents + rel->r_offset - 2);
3018 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3019 contents + rel->r_offset - 1);
3020 }
3021 else
3022 BFD_FAIL ();
3023 if (r_type == R_386_TLS_GOTIE)
3024 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3025 contents + rel->r_offset);
3026 else
3027 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3028 contents + rel->r_offset);
3029 continue;
3030 }
3031 }
3032
3033 if (htab->elf.sgot == NULL)
3034 abort ();
3035
3036 if (h != NULL)
3037 {
3038 off = h->got.offset;
3039 offplt = elf_x86_hash_entry (h)->tlsdesc_got;
3040 }
3041 else
3042 {
3043 if (local_got_offsets == NULL)
3044 abort ();
3045
3046 off = local_got_offsets[r_symndx];
3047 offplt = local_tlsdesc_gotents[r_symndx];
3048 }
3049
3050 if ((off & 1) != 0)
3051 off &= ~1;
3052 else
3053 {
3054 Elf_Internal_Rela outrel;
3055 int dr_type;
3056 asection *sreloc;
3057
3058 if (htab->elf.srelgot == NULL)
3059 abort ();
3060
3061 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3062
3063 if (GOT_TLS_GDESC_P (tls_type))
3064 {
3065 bfd_byte *loc;
3066 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3067 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3068 <= htab->elf.sgotplt->size);
3069 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3070 + htab->elf.sgotplt->output_offset
3071 + offplt
3072 + htab->sgotplt_jump_table_size);
3073 sreloc = htab->elf.srelplt;
3074 loc = sreloc->contents;
3075 loc += (htab->next_tls_desc_index++
3076 * sizeof (Elf32_External_Rel));
3077 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3078 <= sreloc->contents + sreloc->size);
3079 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3080 if (indx == 0)
3081 {
3082 BFD_ASSERT (! unresolved_reloc);
3083 bfd_put_32 (output_bfd,
3084 relocation - _bfd_x86_elf_dtpoff_base (info),
3085 htab->elf.sgotplt->contents + offplt
3086 + htab->sgotplt_jump_table_size + 4);
3087 }
3088 else
3089 {
3090 bfd_put_32 (output_bfd, 0,
3091 htab->elf.sgotplt->contents + offplt
3092 + htab->sgotplt_jump_table_size + 4);
3093 }
3094 }
3095
3096 sreloc = htab->elf.srelgot;
3097
3098 outrel.r_offset = (htab->elf.sgot->output_section->vma
3099 + htab->elf.sgot->output_offset + off);
3100
3101 if (GOT_TLS_GD_P (tls_type))
3102 dr_type = R_386_TLS_DTPMOD32;
3103 else if (GOT_TLS_GDESC_P (tls_type))
3104 goto dr_done;
3105 else if (tls_type == GOT_TLS_IE_POS)
3106 dr_type = R_386_TLS_TPOFF;
3107 else
3108 dr_type = R_386_TLS_TPOFF32;
3109
3110 if (dr_type == R_386_TLS_TPOFF && indx == 0)
3111 bfd_put_32 (output_bfd,
3112 relocation - _bfd_x86_elf_dtpoff_base (info),
3113 htab->elf.sgot->contents + off);
3114 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3115 bfd_put_32 (output_bfd,
3116 _bfd_x86_elf_dtpoff_base (info) - relocation,
3117 htab->elf.sgot->contents + off);
3118 else if (dr_type != R_386_TLS_DESC)
3119 bfd_put_32 (output_bfd, 0,
3120 htab->elf.sgot->contents + off);
3121 outrel.r_info = ELF32_R_INFO (indx, dr_type);
3122
3123 elf_append_rel (output_bfd, sreloc, &outrel);
3124
3125 if (GOT_TLS_GD_P (tls_type))
3126 {
3127 if (indx == 0)
3128 {
3129 BFD_ASSERT (! unresolved_reloc);
3130 bfd_put_32 (output_bfd,
3131 relocation - _bfd_x86_elf_dtpoff_base (info),
3132 htab->elf.sgot->contents + off + 4);
3133 }
3134 else
3135 {
3136 bfd_put_32 (output_bfd, 0,
3137 htab->elf.sgot->contents + off + 4);
3138 outrel.r_info = ELF32_R_INFO (indx,
3139 R_386_TLS_DTPOFF32);
3140 outrel.r_offset += 4;
3141 elf_append_rel (output_bfd, sreloc, &outrel);
3142 }
3143 }
3144 else if (tls_type == GOT_TLS_IE_BOTH)
3145 {
3146 bfd_put_32 (output_bfd,
3147 (indx == 0
3148 ? relocation - _bfd_x86_elf_dtpoff_base (info)
3149 : 0),
3150 htab->elf.sgot->contents + off + 4);
3151 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3152 outrel.r_offset += 4;
3153 elf_append_rel (output_bfd, sreloc, &outrel);
3154 }
3155
3156 dr_done:
3157 if (h != NULL)
3158 h->got.offset |= 1;
3159 else
3160 local_got_offsets[r_symndx] |= 1;
3161 }
3162
3163 if (off >= (bfd_vma) -2
3164 && ! GOT_TLS_GDESC_P (tls_type))
3165 abort ();
3166 if (r_type_tls == R_386_TLS_GOTDESC
3167 || r_type_tls == R_386_TLS_DESC_CALL)
3168 {
3169 relocation = htab->sgotplt_jump_table_size + offplt;
3170 unresolved_reloc = false;
3171 }
3172 else if (r_type_tls == r_type)
3173 {
3174 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
3175 + htab->elf.sgotplt->output_offset;
3176 relocation = htab->elf.sgot->output_section->vma
3177 + htab->elf.sgot->output_offset + off - g_o_t;
3178 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3179 && tls_type == GOT_TLS_IE_BOTH)
3180 relocation += 4;
3181 if (r_type == R_386_TLS_IE)
3182 relocation += g_o_t;
3183 unresolved_reloc = false;
3184 }
3185 else if (r_type == R_386_TLS_GD)
3186 {
3187 unsigned int val, type;
3188 bfd_vma roff;
3189
3190 /* GD->IE transition. */
3191 type = *(contents + rel->r_offset - 2);
3192 val = *(contents + rel->r_offset - 1);
3193 if (type == 0x04)
3194 {
3195 /* Change
3196 leal foo@tlsgd(,%ebx,1), %eax
3197 call ___tls_get_addr@PLT
3198 into:
3199 movl %gs:0, %eax
3200 subl $foo@gottpoff(%ebx), %eax. */
3201 val >>= 3;
3202 roff = rel->r_offset - 3;
3203 }
3204 else
3205 {
3206 /* Change
3207 leal foo@tlsgd(%ebx), %eax
3208 call ___tls_get_addr@PLT
3209 nop
3210 or
3211 leal foo@tlsgd(%reg), %eax
3212 call *___tls_get_addr@GOT(%reg)
3213 which may be converted to
3214 addr32 call ___tls_get_addr
3215 into:
3216 movl %gs:0, %eax;
3217 subl $foo@gottpoff(%reg), %eax. */
3218 roff = rel->r_offset - 2;
3219 }
3220 memcpy (contents + roff,
3221 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3222 contents[roff + 7] = 0x80 | (val & 7);
3223 /* If foo is used only with foo@gotntpoff(%reg) and
3224 foo@indntpoff, but not with foo@gottpoff(%reg), change
3225 subl $foo@gottpoff(%reg), %eax
3226 into:
3227 addl $foo@gotntpoff(%reg), %eax. */
3228 if (tls_type == GOT_TLS_IE_POS)
3229 contents[roff + 6] = 0x03;
3230 bfd_put_32 (output_bfd,
3231 htab->elf.sgot->output_section->vma
3232 + htab->elf.sgot->output_offset + off
3233 - htab->elf.sgotplt->output_section->vma
3234 - htab->elf.sgotplt->output_offset,
3235 contents + roff + 8);
3236 /* Skip R_386_PLT32 and R_386_GOT32X. */
3237 rel++;
3238 wrel++;
3239 continue;
3240 }
3241 else if (r_type == R_386_TLS_GOTDESC)
3242 {
3243 /* GDesc -> IE transition.
3244 It's originally something like:
3245 leal x@tlsdesc(%ebx), %eax
3246
3247 Change it to:
3248 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3249 or:
3250 movl x@gottpoff(%ebx), %eax # before negl %eax
3251
3252 Registers other than %eax may be set up here. */
3253
3254 bfd_vma roff;
3255
3256 /* First, make sure it's a leal adding ebx to a 32-bit
3257 offset into any register, although it's probably
3258 almost always going to be eax. */
3259 roff = rel->r_offset;
3260
3261 /* Now modify the instruction as appropriate. */
3262 /* To turn a leal into a movl in the form we use it, it
3263 suffices to change the first byte from 0x8d to 0x8b.
3264 aoliva FIXME: should we decide to keep the leal, all
3265 we have to do is remove the statement below, and
3266 adjust the relaxation of R_386_TLS_DESC_CALL. */
3267 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3268
3269 if (tls_type == GOT_TLS_IE_BOTH)
3270 off += 4;
3271
3272 bfd_put_32 (output_bfd,
3273 htab->elf.sgot->output_section->vma
3274 + htab->elf.sgot->output_offset + off
3275 - htab->elf.sgotplt->output_section->vma
3276 - htab->elf.sgotplt->output_offset,
3277 contents + roff);
3278 continue;
3279 }
3280 else if (r_type == R_386_TLS_DESC_CALL)
3281 {
3282 /* GDesc -> IE transition.
3283 It's originally:
3284 call *(%eax)
3285
3286 Change it to:
3287 xchg %ax,%ax
3288 or
3289 negl %eax
3290 depending on how we transformed the TLS_GOTDESC above.
3291 */
3292
3293 bfd_vma roff;
3294
3295 roff = rel->r_offset;
3296
3297 /* Now modify the instruction as appropriate. */
3298 if (tls_type != GOT_TLS_IE_NEG)
3299 {
3300 /* xchg %ax,%ax */
3301 bfd_put_8 (output_bfd, 0x66, contents + roff);
3302 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3303 }
3304 else
3305 {
3306 /* negl %eax */
3307 bfd_put_8 (output_bfd, 0xf7, contents + roff);
3308 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3309 }
3310
3311 continue;
3312 }
3313 else
3314 BFD_ASSERT (false);
3315 break;
3316
3317 case R_386_TLS_LDM:
3318 if (! elf_i386_tls_transition (info, input_bfd,
3319 input_section, contents,
3320 symtab_hdr, sym_hashes,
3321 &r_type, GOT_UNKNOWN, rel,
3322 relend, h, r_symndx, true))
3323 return false;
3324
3325 if (r_type != R_386_TLS_LDM)
3326 {
3327 /* LD->LE transition. Change
3328 leal foo@tlsldm(%ebx) %eax
3329 call ___tls_get_addr@PLT
3330 into:
3331 movl %gs:0, %eax
3332 nop
3333 leal 0(%esi,1), %esi
3334 or change
3335 leal foo@tlsldm(%reg) %eax
3336 call *___tls_get_addr@GOT(%reg)
3337 which may be converted to
3338 addr32 call ___tls_get_addr
3339 into:
3340 movl %gs:0, %eax
3341 leal 0(%esi), %esi */
3342 BFD_ASSERT (r_type == R_386_TLS_LE_32);
3343 if (*(contents + rel->r_offset + 4) == 0xff
3344 || *(contents + rel->r_offset + 4) == 0x67)
3345 memcpy (contents + rel->r_offset - 2,
3346 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
3347 else
3348 memcpy (contents + rel->r_offset - 2,
3349 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3350 /* Skip R_386_PC32/R_386_PLT32. */
3351 rel++;
3352 wrel++;
3353 continue;
3354 }
3355
3356 if (htab->elf.sgot == NULL)
3357 abort ();
3358
3359 off = htab->tls_ld_or_ldm_got.offset;
3360 if (off & 1)
3361 off &= ~1;
3362 else
3363 {
3364 Elf_Internal_Rela outrel;
3365
3366 if (htab->elf.srelgot == NULL)
3367 abort ();
3368
3369 outrel.r_offset = (htab->elf.sgot->output_section->vma
3370 + htab->elf.sgot->output_offset + off);
3371
3372 bfd_put_32 (output_bfd, 0,
3373 htab->elf.sgot->contents + off);
3374 bfd_put_32 (output_bfd, 0,
3375 htab->elf.sgot->contents + off + 4);
3376 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3377 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
3378 htab->tls_ld_or_ldm_got.offset |= 1;
3379 }
3380 relocation = htab->elf.sgot->output_section->vma
3381 + htab->elf.sgot->output_offset + off
3382 - htab->elf.sgotplt->output_section->vma
3383 - htab->elf.sgotplt->output_offset;
3384 unresolved_reloc = false;
3385 break;
3386
3387 case R_386_TLS_LDO_32:
3388 if (!bfd_link_executable (info)
3389 || (input_section->flags & SEC_CODE) == 0)
3390 relocation -= _bfd_x86_elf_dtpoff_base (info);
3391 else
3392 /* When converting LDO to LE, we must negate. */
3393 relocation = -elf_i386_tpoff (info, relocation);
3394 break;
3395
3396 case R_386_TLS_LE_32:
3397 case R_386_TLS_LE:
3398 if (!bfd_link_executable (info))
3399 {
3400 Elf_Internal_Rela outrel;
3401 asection *sreloc;
3402
3403 outrel.r_offset = rel->r_offset
3404 + input_section->output_section->vma
3405 + input_section->output_offset;
3406 if (h != NULL && h->dynindx != -1)
3407 indx = h->dynindx;
3408 else
3409 indx = 0;
3410 if (r_type == R_386_TLS_LE_32)
3411 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3412 else
3413 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3414 sreloc = elf_section_data (input_section)->sreloc;
3415 if (sreloc == NULL)
3416 abort ();
3417 elf_append_rel (output_bfd, sreloc, &outrel);
3418 if (indx)
3419 continue;
3420 else if (r_type == R_386_TLS_LE_32)
3421 relocation = _bfd_x86_elf_dtpoff_base (info) - relocation;
3422 else
3423 relocation -= _bfd_x86_elf_dtpoff_base (info);
3424 }
3425 else if (r_type == R_386_TLS_LE_32)
3426 relocation = elf_i386_tpoff (info, relocation);
3427 else
3428 relocation = -elf_i386_tpoff (info, relocation);
3429 break;
3430
3431 default:
3432 break;
3433 }
3434
3435 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3436 because such sections are not SEC_ALLOC and thus ld.so will
3437 not process them. */
3438 if (unresolved_reloc
3439 && !((input_section->flags & SEC_DEBUGGING) != 0
3440 && h->def_dynamic)
3441 && _bfd_elf_section_offset (output_bfd, info, input_section,
3442 rel->r_offset) != (bfd_vma) -1)
3443 {
3444 _bfd_error_handler
3445 /* xgettext:c-format */
3446 (_("%pB(%pA+%#" PRIx64 "): unresolvable %s relocation against symbol `%s'"),
3447 input_bfd,
3448 input_section,
3449 (uint64_t) rel->r_offset,
3450 howto->name,
3451 h->root.root.string);
3452 return false;
3453 }
3454
3455 do_relocation:
3456 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3457 contents, rel->r_offset,
3458 relocation, 0);
3459
3460 check_relocation_error:
3461 if (r != bfd_reloc_ok)
3462 {
3463 const char *name;
3464
3465 if (h != NULL)
3466 name = h->root.root.string;
3467 else
3468 {
3469 name = bfd_elf_string_from_elf_section (input_bfd,
3470 symtab_hdr->sh_link,
3471 sym->st_name);
3472 if (name == NULL)
3473 return false;
3474 if (*name == '\0')
3475 name = bfd_section_name (sec);
3476 }
3477
3478 if (r == bfd_reloc_overflow)
3479 (*info->callbacks->reloc_overflow)
3480 (info, (h ? &h->root : NULL), name, howto->name,
3481 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3482 else
3483 {
3484 _bfd_error_handler
3485 /* xgettext:c-format */
3486 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3487 input_bfd, input_section,
3488 (uint64_t) rel->r_offset, name, (int) r);
3489 return false;
3490 }
3491 }
3492
3493 if (wrel != rel)
3494 *wrel = *rel;
3495 }
3496
3497 if (wrel != rel)
3498 {
3499 Elf_Internal_Shdr *rel_hdr;
3500 size_t deleted = rel - wrel;
3501
3502 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3503 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3504 if (rel_hdr->sh_size == 0)
3505 {
3506 /* It is too late to remove an empty reloc section. Leave
3507 one NONE reloc.
3508 ??? What is wrong with an empty section??? */
3509 rel_hdr->sh_size = rel_hdr->sh_entsize;
3510 deleted -= 1;
3511 }
3512 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3513 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3514 input_section->reloc_count -= deleted;
3515 }
3516
3517 return true;
3518 }
3519
3520 /* Finish up dynamic symbol handling. We set the contents of various
3521 dynamic sections here. */
3522
3523 static bool
3524 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3525 struct bfd_link_info *info,
3526 struct elf_link_hash_entry *h,
3527 Elf_Internal_Sym *sym)
3528 {
3529 struct elf_x86_link_hash_table *htab;
3530 unsigned plt_entry_size;
3531 struct elf_x86_link_hash_entry *eh;
3532 bool local_undefweak;
3533 bool use_plt_second;
3534
3535 htab = elf_x86_hash_table (info, I386_ELF_DATA);
3536 if (htab == NULL)
3537 return false;
3538
3539 plt_entry_size = htab->plt.plt_entry_size;
3540
3541 /* Use the second PLT section only if there is .plt section. */
3542 use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3543
3544 eh = (struct elf_x86_link_hash_entry *) h;
3545 if (eh->no_finish_dynamic_symbol)
3546 abort ();
3547
3548 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3549 resolved undefined weak symbols in executable so that their
3550 references have value 0 at run-time. */
3551 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3552
3553 if (h->plt.offset != (bfd_vma) -1)
3554 {
3555 bfd_vma plt_index, plt_offset;
3556 bfd_vma got_offset;
3557 Elf_Internal_Rela rel;
3558 bfd_byte *loc;
3559 asection *plt, *resolved_plt, *gotplt, *relplt;
3560
3561 /* When building a static executable, use .iplt, .igot.plt and
3562 .rel.iplt sections for STT_GNU_IFUNC symbols. */
3563 if (htab->elf.splt != NULL)
3564 {
3565 plt = htab->elf.splt;
3566 gotplt = htab->elf.sgotplt;
3567 relplt = htab->elf.srelplt;
3568 }
3569 else
3570 {
3571 plt = htab->elf.iplt;
3572 gotplt = htab->elf.igotplt;
3573 relplt = htab->elf.irelplt;
3574 }
3575
3576 VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3577
3578 /* Get the index in the procedure linkage table which
3579 corresponds to this symbol. This is the index of this symbol
3580 in all the symbols for which we are making plt entries. The
3581 first entry in the procedure linkage table is reserved.
3582
3583 Get the offset into the .got table of the entry that
3584 corresponds to this function. Each .got entry is 4 bytes.
3585 The first three are reserved.
3586
3587 For static executables, we don't reserve anything. */
3588
3589 if (plt == htab->elf.splt)
3590 {
3591 got_offset = (h->plt.offset / plt_entry_size
3592 - htab->plt.has_plt0);
3593 got_offset = (got_offset + 3) * 4;
3594 }
3595 else
3596 {
3597 got_offset = h->plt.offset / plt_entry_size;
3598 got_offset = got_offset * 4;
3599 }
3600
3601 /* Fill in the entry in the procedure linkage table and update
3602 the first slot. */
3603 memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3604 plt_entry_size);
3605
3606 if (use_plt_second)
3607 {
3608 const bfd_byte *plt_entry;
3609 if (bfd_link_pic (info))
3610 plt_entry = htab->non_lazy_plt->pic_plt_entry;
3611 else
3612 plt_entry = htab->non_lazy_plt->plt_entry;
3613 memcpy (htab->plt_second->contents + eh->plt_second.offset,
3614 plt_entry, htab->non_lazy_plt->plt_entry_size);
3615
3616 resolved_plt = htab->plt_second;
3617 plt_offset = eh->plt_second.offset;
3618 }
3619 else
3620 {
3621 resolved_plt = plt;
3622 plt_offset = h->plt.offset;
3623 }
3624
3625 if (! bfd_link_pic (info))
3626 {
3627 bfd_put_32 (output_bfd,
3628 (gotplt->output_section->vma
3629 + gotplt->output_offset
3630 + got_offset),
3631 resolved_plt->contents + plt_offset
3632 + htab->plt.plt_got_offset);
3633
3634 if (htab->elf.target_os == is_vxworks)
3635 {
3636 int s, k, reloc_index;
3637
3638 /* Create the R_386_32 relocation referencing the GOT
3639 for this PLT entry. */
3640
3641 /* S: Current slot number (zero-based). */
3642 s = ((h->plt.offset - htab->plt.plt_entry_size)
3643 / htab->plt.plt_entry_size);
3644 /* K: Number of relocations for PLTResolve. */
3645 if (bfd_link_pic (info))
3646 k = PLTRESOLVE_RELOCS_SHLIB;
3647 else
3648 k = PLTRESOLVE_RELOCS;
3649 /* Skip the PLTresolve relocations, and the relocations for
3650 the other PLT slots. */
3651 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3652 loc = (htab->srelplt2->contents + reloc_index
3653 * sizeof (Elf32_External_Rel));
3654
3655 rel.r_offset = (plt->output_section->vma
3656 + plt->output_offset
3657 + h->plt.offset + 2),
3658 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3659 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3660
3661 /* Create the R_386_32 relocation referencing the beginning of
3662 the PLT for this GOT entry. */
3663 rel.r_offset = (htab->elf.sgotplt->output_section->vma
3664 + htab->elf.sgotplt->output_offset
3665 + got_offset);
3666 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3667 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3668 loc + sizeof (Elf32_External_Rel));
3669 }
3670 }
3671 else
3672 {
3673 bfd_put_32 (output_bfd, got_offset,
3674 resolved_plt->contents + plt_offset
3675 + htab->plt.plt_got_offset);
3676 }
3677
3678 /* Fill in the entry in the global offset table. Leave the entry
3679 as zero for undefined weak symbol in PIE. No PLT relocation
3680 against undefined weak symbol in PIE. */
3681 if (!local_undefweak)
3682 {
3683 if (htab->plt.has_plt0)
3684 bfd_put_32 (output_bfd,
3685 (plt->output_section->vma
3686 + plt->output_offset
3687 + h->plt.offset
3688 + htab->lazy_plt->plt_lazy_offset),
3689 gotplt->contents + got_offset);
3690
3691 /* Fill in the entry in the .rel.plt section. */
3692 rel.r_offset = (gotplt->output_section->vma
3693 + gotplt->output_offset
3694 + got_offset);
3695 if (PLT_LOCAL_IFUNC_P (info, h))
3696 {
3697 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3698 h->root.root.string,
3699 h->root.u.def.section->owner);
3700
3701 /* If an STT_GNU_IFUNC symbol is locally defined, generate
3702 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
3703 in the .got.plt section. */
3704 bfd_put_32 (output_bfd,
3705 (h->root.u.def.value
3706 + h->root.u.def.section->output_section->vma
3707 + h->root.u.def.section->output_offset),
3708 gotplt->contents + got_offset);
3709 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3710
3711 if (htab->params->report_relative_reloc)
3712 _bfd_x86_elf_link_report_relative_reloc
3713 (info, relplt, h, sym, "R_386_IRELATIVE", &rel);
3714
3715 /* R_386_IRELATIVE comes last. */
3716 plt_index = htab->next_irelative_index--;
3717 }
3718 else
3719 {
3720 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3721 plt_index = htab->next_jump_slot_index++;
3722 }
3723
3724 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
3725 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3726
3727 /* Don't fill the second and third slots in PLT entry for
3728 static executables nor without PLT0. */
3729 if (plt == htab->elf.splt && htab->plt.has_plt0)
3730 {
3731 bfd_put_32 (output_bfd,
3732 plt_index * sizeof (Elf32_External_Rel),
3733 plt->contents + h->plt.offset
3734 + htab->lazy_plt->plt_reloc_offset);
3735 bfd_put_32 (output_bfd,
3736 - (h->plt.offset
3737 + htab->lazy_plt->plt_plt_offset + 4),
3738 (plt->contents + h->plt.offset
3739 + htab->lazy_plt->plt_plt_offset));
3740 }
3741 }
3742 }
3743 else if (eh->plt_got.offset != (bfd_vma) -1)
3744 {
3745 bfd_vma got_offset, plt_offset;
3746 asection *plt, *got, *gotplt;
3747 const bfd_byte *got_plt_entry;
3748
3749 /* Set the entry in the GOT procedure linkage table. */
3750 plt = htab->plt_got;
3751 got = htab->elf.sgot;
3752 gotplt = htab->elf.sgotplt;
3753 got_offset = h->got.offset;
3754
3755 if (got_offset == (bfd_vma) -1
3756 || plt == NULL
3757 || got == NULL
3758 || gotplt == NULL)
3759 abort ();
3760
3761 /* Fill in the entry in the GOT procedure linkage table. */
3762 if (! bfd_link_pic (info))
3763 {
3764 got_plt_entry = htab->non_lazy_plt->plt_entry;
3765 got_offset += got->output_section->vma + got->output_offset;
3766 }
3767 else
3768 {
3769 got_plt_entry = htab->non_lazy_plt->pic_plt_entry;
3770 got_offset += (got->output_section->vma
3771 + got->output_offset
3772 - gotplt->output_section->vma
3773 - gotplt->output_offset);
3774 }
3775
3776 plt_offset = eh->plt_got.offset;
3777 memcpy (plt->contents + plt_offset, got_plt_entry,
3778 htab->non_lazy_plt->plt_entry_size);
3779 bfd_put_32 (output_bfd, got_offset,
3780 (plt->contents + plt_offset
3781 + htab->non_lazy_plt->plt_got_offset));
3782 }
3783
3784 if (!local_undefweak
3785 && !h->def_regular
3786 && (h->plt.offset != (bfd_vma) -1
3787 || eh->plt_got.offset != (bfd_vma) -1))
3788 {
3789 /* Mark the symbol as undefined, rather than as defined in
3790 the .plt section. Leave the value if there were any
3791 relocations where pointer equality matters (this is a clue
3792 for the dynamic linker, to make function pointer
3793 comparisons work between an application and shared
3794 library), otherwise set it to zero. If a function is only
3795 called from a binary, there is no need to slow down
3796 shared libraries because of that. */
3797 sym->st_shndx = SHN_UNDEF;
3798 if (!h->pointer_equality_needed)
3799 sym->st_value = 0;
3800 }
3801
3802 _bfd_x86_elf_link_fixup_ifunc_symbol (info, htab, h, sym);
3803
3804 /* Don't generate dynamic GOT relocation against undefined weak
3805 symbol in executable. */
3806 if (h->got.offset != (bfd_vma) -1
3807 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry(h)->tls_type)
3808 && (elf_x86_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
3809 && !local_undefweak)
3810 {
3811 Elf_Internal_Rela rel;
3812 asection *relgot = htab->elf.srelgot;
3813 const char *relative_reloc_name = NULL;
3814 bool generate_dynamic_reloc = true;
3815
3816 /* This symbol has an entry in the global offset table. Set it
3817 up. */
3818
3819 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3820 abort ();
3821
3822 rel.r_offset = (htab->elf.sgot->output_section->vma
3823 + htab->elf.sgot->output_offset
3824 + (h->got.offset & ~(bfd_vma) 1));
3825
3826 /* If this is a static link, or it is a -Bsymbolic link and the
3827 symbol is defined locally or was forced to be local because
3828 of a version file, we just want to emit a RELATIVE reloc.
3829 The entry in the global offset table will already have been
3830 initialized in the relocate_section function. */
3831 if (h->def_regular
3832 && h->type == STT_GNU_IFUNC)
3833 {
3834 if (h->plt.offset == (bfd_vma) -1)
3835 {
3836 /* STT_GNU_IFUNC is referenced without PLT. */
3837 if (htab->elf.splt == NULL)
3838 {
3839 /* use .rel[a].iplt section to store .got relocations
3840 in static executable. */
3841 relgot = htab->elf.irelplt;
3842 }
3843 if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3844 {
3845 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3846 h->root.root.string,
3847 h->root.u.def.section->owner);
3848
3849 bfd_put_32 (output_bfd,
3850 (h->root.u.def.value
3851 + h->root.u.def.section->output_section->vma
3852 + h->root.u.def.section->output_offset),
3853 htab->elf.sgot->contents + h->got.offset);
3854 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3855 relative_reloc_name = "R_386_IRELATIVE";
3856 }
3857 else
3858 goto do_glob_dat;
3859 }
3860 else if (bfd_link_pic (info))
3861 {
3862 /* Generate R_386_GLOB_DAT. */
3863 goto do_glob_dat;
3864 }
3865 else
3866 {
3867 asection *plt;
3868 bfd_vma plt_offset;
3869
3870 if (!h->pointer_equality_needed)
3871 abort ();
3872
3873 /* For non-shared object, we can't use .got.plt, which
3874 contains the real function addres if we need pointer
3875 equality. We load the GOT entry with the PLT entry. */
3876 if (htab->plt_second != NULL)
3877 {
3878 plt = htab->plt_second;
3879 plt_offset = eh->plt_second.offset;
3880 }
3881 else
3882 {
3883 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3884 plt_offset = h->plt.offset;
3885 }
3886 bfd_put_32 (output_bfd,
3887 (plt->output_section->vma
3888 + plt->output_offset + plt_offset),
3889 htab->elf.sgot->contents + h->got.offset);
3890 return true;
3891 }
3892 }
3893 else if (bfd_link_pic (info)
3894 && SYMBOL_REFERENCES_LOCAL_P (info, h))
3895 {
3896 BFD_ASSERT((h->got.offset & 1) != 0);
3897 if (info->enable_dt_relr)
3898 generate_dynamic_reloc = false;
3899 else
3900 {
3901 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3902 relative_reloc_name = "R_386_RELATIVE";
3903 }
3904 }
3905 else
3906 {
3907 BFD_ASSERT((h->got.offset & 1) == 0);
3908 do_glob_dat:
3909 bfd_put_32 (output_bfd, (bfd_vma) 0,
3910 htab->elf.sgot->contents + h->got.offset);
3911 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3912 }
3913
3914 if (generate_dynamic_reloc)
3915 {
3916 if (relative_reloc_name != NULL
3917 && htab->params->report_relative_reloc)
3918 _bfd_x86_elf_link_report_relative_reloc
3919 (info, relgot, h, sym, relative_reloc_name, &rel);
3920
3921 elf_append_rel (output_bfd, relgot, &rel);
3922 }
3923 }
3924
3925 if (h->needs_copy)
3926 {
3927 Elf_Internal_Rela rel;
3928 asection *s;
3929
3930 /* This symbol needs a copy reloc. Set it up. */
3931 VERIFY_COPY_RELOC (h, htab)
3932
3933 rel.r_offset = (h->root.u.def.value
3934 + h->root.u.def.section->output_section->vma
3935 + h->root.u.def.section->output_offset);
3936 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3937 if (h->root.u.def.section == htab->elf.sdynrelro)
3938 s = htab->elf.sreldynrelro;
3939 else
3940 s = htab->elf.srelbss;
3941 elf_append_rel (output_bfd, s, &rel);
3942 }
3943
3944 return true;
3945 }
3946
3947 /* Finish up local dynamic symbol handling. We set the contents of
3948 various dynamic sections here. */
3949
3950 static int
3951 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
3952 {
3953 struct elf_link_hash_entry *h
3954 = (struct elf_link_hash_entry *) *slot;
3955 struct bfd_link_info *info
3956 = (struct bfd_link_info *) inf;
3957
3958 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
3959 h, NULL);
3960 }
3961
3962 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
3963 here since undefined weak symbol may not be dynamic and may not be
3964 called for elf_i386_finish_dynamic_symbol. */
3965
3966 static bool
3967 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
3968 void *inf)
3969 {
3970 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
3971 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3972
3973 if (h->root.type != bfd_link_hash_undefweak
3974 || h->dynindx != -1)
3975 return true;
3976
3977 return elf_i386_finish_dynamic_symbol (info->output_bfd,
3978 info, h, NULL);
3979 }
3980
3981 /* Used to decide how to sort relocs in an optimal manner for the
3982 dynamic linker, before writing them out. */
3983
3984 static enum elf_reloc_type_class
3985 elf_i386_reloc_type_class (const struct bfd_link_info *info,
3986 const asection *rel_sec ATTRIBUTE_UNUSED,
3987 const Elf_Internal_Rela *rela)
3988 {
3989 bfd *abfd = info->output_bfd;
3990 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3991 struct elf_link_hash_table *htab = elf_hash_table (info);
3992
3993 if (htab->dynsym != NULL
3994 && htab->dynsym->contents != NULL)
3995 {
3996 /* Check relocation against STT_GNU_IFUNC symbol if there are
3997 dynamic symbols. */
3998 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3999 if (r_symndx != STN_UNDEF)
4000 {
4001 Elf_Internal_Sym sym;
4002 if (!bed->s->swap_symbol_in (abfd,
4003 (htab->dynsym->contents
4004 + r_symndx * sizeof (Elf32_External_Sym)),
4005 0, &sym))
4006 abort ();
4007
4008 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
4009 return reloc_class_ifunc;
4010 }
4011 }
4012
4013 switch (ELF32_R_TYPE (rela->r_info))
4014 {
4015 case R_386_IRELATIVE:
4016 return reloc_class_ifunc;
4017 case R_386_RELATIVE:
4018 return reloc_class_relative;
4019 case R_386_JUMP_SLOT:
4020 return reloc_class_plt;
4021 case R_386_COPY:
4022 return reloc_class_copy;
4023 default:
4024 return reloc_class_normal;
4025 }
4026 }
4027
4028 /* Finish up the dynamic sections. */
4029
4030 static bool
4031 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4032 struct bfd_link_info *info)
4033 {
4034 struct elf_x86_link_hash_table *htab;
4035
4036 htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
4037 if (htab == NULL)
4038 return false;
4039
4040 if (!htab->elf.dynamic_sections_created)
4041 return true;
4042
4043 if (htab->elf.splt && htab->elf.splt->size > 0)
4044 {
4045 if (bfd_is_abs_section (htab->elf.splt->output_section))
4046 {
4047 info->callbacks->einfo
4048 (_("%F%P: discarded output section: `%pA'\n"),
4049 htab->elf.splt);
4050 return false;
4051 }
4052
4053 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4054 really seem like the right value. */
4055 elf_section_data (htab->elf.splt->output_section)
4056 ->this_hdr.sh_entsize = 4;
4057
4058 if (htab->plt.has_plt0)
4059 {
4060 /* Fill in the special first entry in the procedure linkage
4061 table. */
4062 memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
4063 htab->lazy_plt->plt0_entry_size);
4064 memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
4065 htab->plt0_pad_byte,
4066 htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
4067 if (!bfd_link_pic (info))
4068 {
4069 bfd_put_32 (output_bfd,
4070 (htab->elf.sgotplt->output_section->vma
4071 + htab->elf.sgotplt->output_offset
4072 + 4),
4073 htab->elf.splt->contents
4074 + htab->lazy_plt->plt0_got1_offset);
4075 bfd_put_32 (output_bfd,
4076 (htab->elf.sgotplt->output_section->vma
4077 + htab->elf.sgotplt->output_offset
4078 + 8),
4079 htab->elf.splt->contents
4080 + htab->lazy_plt->plt0_got2_offset);
4081
4082 if (htab->elf.target_os == is_vxworks)
4083 {
4084 Elf_Internal_Rela rel;
4085 int num_plts = (htab->elf.splt->size
4086 / htab->plt.plt_entry_size) - 1;
4087 unsigned char *p;
4088 asection *srelplt2 = htab->srelplt2;
4089
4090 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4091 + 4. On IA32 we use REL relocations so the
4092 addend goes in the PLT directly. */
4093 rel.r_offset = (htab->elf.splt->output_section->vma
4094 + htab->elf.splt->output_offset
4095 + htab->lazy_plt->plt0_got1_offset);
4096 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4097 R_386_32);
4098 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4099 srelplt2->contents);
4100 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4101 + 8. */
4102 rel.r_offset = (htab->elf.splt->output_section->vma
4103 + htab->elf.splt->output_offset
4104 + htab->lazy_plt->plt0_got2_offset);
4105 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4106 R_386_32);
4107 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4108 srelplt2->contents +
4109 sizeof (Elf32_External_Rel));
4110 /* Correct the .rel.plt.unloaded relocations. */
4111 p = srelplt2->contents;
4112 if (bfd_link_pic (info))
4113 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4114 else
4115 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4116
4117 for (; num_plts; num_plts--)
4118 {
4119 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4120 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4121 R_386_32);
4122 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4123 p += sizeof (Elf32_External_Rel);
4124
4125 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4126 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
4127 R_386_32);
4128 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4129 p += sizeof (Elf32_External_Rel);
4130 }
4131 }
4132 }
4133 }
4134 }
4135
4136 /* Fill PLT entries for undefined weak symbols in PIE. */
4137 if (bfd_link_pie (info))
4138 bfd_hash_traverse (&info->hash->table,
4139 elf_i386_pie_finish_undefweak_symbol,
4140 info);
4141
4142 return true;
4143 }
4144
4145 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4146 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4147 It has to be done before elf_link_sort_relocs is called so that
4148 dynamic relocations are properly sorted. */
4149
4150 static bool
4151 elf_i386_output_arch_local_syms
4152 (bfd *output_bfd ATTRIBUTE_UNUSED,
4153 struct bfd_link_info *info,
4154 void *flaginfo ATTRIBUTE_UNUSED,
4155 int (*func) (void *, const char *,
4156 Elf_Internal_Sym *,
4157 asection *,
4158 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4159 {
4160 struct elf_x86_link_hash_table *htab
4161 = elf_x86_hash_table (info, I386_ELF_DATA);
4162 if (htab == NULL)
4163 return false;
4164
4165 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4166 htab_traverse (htab->loc_hash_table,
4167 elf_i386_finish_local_dynamic_symbol,
4168 info);
4169
4170 return true;
4171 }
4172
4173 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
4174 dynamic relocations. */
4175
4176 static long
4177 elf_i386_get_synthetic_symtab (bfd *abfd,
4178 long symcount ATTRIBUTE_UNUSED,
4179 asymbol **syms ATTRIBUTE_UNUSED,
4180 long dynsymcount,
4181 asymbol **dynsyms,
4182 asymbol **ret)
4183 {
4184 long count, i, n;
4185 int j;
4186 bfd_byte *plt_contents;
4187 long relsize;
4188 const struct elf_x86_lazy_plt_layout *lazy_plt;
4189 const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4190 const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4191 const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4192 asection *plt;
4193 bfd_vma got_addr;
4194 enum elf_x86_plt_type plt_type;
4195 struct elf_x86_plt plts[] =
4196 {
4197 { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4198 { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4199 { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4200 { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4201 };
4202
4203 *ret = NULL;
4204
4205 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4206 return 0;
4207
4208 if (dynsymcount <= 0)
4209 return 0;
4210
4211 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4212 if (relsize <= 0)
4213 return -1;
4214
4215 non_lazy_plt = NULL;
4216 /* Silence GCC 6. */
4217 lazy_plt = NULL;
4218 non_lazy_ibt_plt = NULL;
4219 lazy_ibt_plt = NULL;
4220 switch (get_elf_backend_data (abfd)->target_os)
4221 {
4222 case is_normal:
4223 case is_solaris:
4224 non_lazy_plt = &elf_i386_non_lazy_plt;
4225 lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4226 non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4227 /* Fall through */
4228 case is_vxworks:
4229 lazy_plt = &elf_i386_lazy_plt;
4230 break;
4231 default:
4232 abort ();
4233 }
4234
4235 got_addr = 0;
4236
4237 count = 0;
4238 for (j = 0; plts[j].name != NULL; j++)
4239 {
4240 plt = bfd_get_section_by_name (abfd, plts[j].name);
4241 if (plt == NULL || plt->size == 0)
4242 continue;
4243
4244 /* Get the PLT section contents. */
4245 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4246 if (plt_contents == NULL)
4247 break;
4248 if (!bfd_get_section_contents (abfd, (asection *) plt,
4249 plt_contents, 0, plt->size))
4250 {
4251 free (plt_contents);
4252 break;
4253 }
4254
4255 /* Check what kind of PLT it is. */
4256 plt_type = plt_unknown;
4257 if (plts[j].type == plt_unknown
4258 && (plt->size >= (lazy_plt->plt0_entry_size
4259 + lazy_plt->plt_entry_size)))
4260 {
4261 /* Match lazy PLT first. */
4262 if (memcmp (plt_contents, lazy_plt->plt0_entry,
4263 lazy_plt->plt0_got1_offset) == 0)
4264 {
4265 /* The fist entry in the lazy IBT PLT is the same as the
4266 normal lazy PLT. */
4267 if (lazy_ibt_plt != NULL
4268 && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4269 lazy_ibt_plt->plt_entry,
4270 lazy_ibt_plt->plt_got_offset) == 0))
4271 plt_type = plt_lazy | plt_second;
4272 else
4273 plt_type = plt_lazy;
4274 }
4275 else if (memcmp (plt_contents, lazy_plt->pic_plt0_entry,
4276 lazy_plt->plt0_got1_offset) == 0)
4277 {
4278 /* The fist entry in the PIC lazy IBT PLT is the same as
4279 the normal PIC lazy PLT. */
4280 if (lazy_ibt_plt != NULL
4281 && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4282 lazy_ibt_plt->pic_plt_entry,
4283 lazy_ibt_plt->plt_got_offset) == 0))
4284 plt_type = plt_lazy | plt_pic | plt_second;
4285 else
4286 plt_type = plt_lazy | plt_pic;
4287 }
4288 }
4289
4290 if (non_lazy_plt != NULL
4291 && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4292 && plt->size >= non_lazy_plt->plt_entry_size)
4293 {
4294 /* Match non-lazy PLT. */
4295 if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4296 non_lazy_plt->plt_got_offset) == 0)
4297 plt_type = plt_non_lazy;
4298 else if (memcmp (plt_contents, non_lazy_plt->pic_plt_entry,
4299 non_lazy_plt->plt_got_offset) == 0)
4300 plt_type = plt_pic;
4301 }
4302
4303 if ((non_lazy_ibt_plt != NULL)
4304 && (plt_type == plt_unknown || plt_type == plt_second)
4305 && plt->size >= non_lazy_ibt_plt->plt_entry_size)
4306 {
4307 if (memcmp (plt_contents,
4308 non_lazy_ibt_plt->plt_entry,
4309 non_lazy_ibt_plt->plt_got_offset) == 0)
4310 {
4311 /* Match IBT PLT. */
4312 plt_type = plt_second;
4313 non_lazy_plt = non_lazy_ibt_plt;
4314 }
4315 else if (memcmp (plt_contents,
4316 non_lazy_ibt_plt->pic_plt_entry,
4317 non_lazy_ibt_plt->plt_got_offset) == 0)
4318 {
4319 /* Match PIC IBT PLT. */
4320 plt_type = plt_second | plt_pic;
4321 non_lazy_plt = non_lazy_ibt_plt;
4322 }
4323 }
4324
4325 if (plt_type == plt_unknown)
4326 {
4327 free (plt_contents);
4328 continue;
4329 }
4330
4331 plts[j].sec = plt;
4332 plts[j].type = plt_type;
4333
4334 if ((plt_type & plt_lazy))
4335 {
4336 plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4337 plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4338 /* Skip PLT0 in lazy PLT. */
4339 i = 1;
4340 }
4341 else
4342 {
4343 plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4344 plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4345 i = 0;
4346 }
4347
4348 /* Skip lazy PLT when the second PLT is used. */
4349 if ((plt_type & (plt_lazy | plt_second))
4350 == (plt_lazy | plt_second))
4351 plts[j].count = 0;
4352 else
4353 {
4354 n = plt->size / plts[j].plt_entry_size;
4355 plts[j].count = n;
4356 count += n - i;
4357 }
4358
4359 plts[j].contents = plt_contents;
4360
4361 /* The _GLOBAL_OFFSET_TABLE_ address is needed. */
4362 if ((plt_type & plt_pic))
4363 got_addr = (bfd_vma) -1;
4364 }
4365
4366 return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4367 got_addr, plts, dynsyms,
4368 ret);
4369 }
4370
4371 /* Set up i386 GNU properties. Return the first relocatable ELF input
4372 with GNU properties if found. Otherwise, return NULL. */
4373
4374 static bfd *
4375 elf_i386_link_setup_gnu_properties (struct bfd_link_info *info)
4376 {
4377 struct elf_x86_init_table init_table;
4378
4379 switch (get_elf_backend_data (info->output_bfd)->target_os)
4380 {
4381 case is_normal:
4382 case is_solaris:
4383 init_table.plt0_pad_byte = 0x0;
4384 init_table.lazy_plt = &elf_i386_lazy_plt;
4385 init_table.non_lazy_plt = &elf_i386_non_lazy_plt;
4386 init_table.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4387 init_table.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4388 break;
4389 case is_vxworks:
4390 init_table.plt0_pad_byte = 0x90;
4391 init_table.lazy_plt = &elf_i386_lazy_plt;
4392 init_table.non_lazy_plt = NULL;
4393 init_table.lazy_ibt_plt = NULL;
4394 init_table.non_lazy_ibt_plt = NULL;
4395 break;
4396 default:
4397 abort ();
4398 }
4399
4400 init_table.r_info = elf32_r_info;
4401 init_table.r_sym = elf32_r_sym;
4402
4403 return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4404 }
4405
4406 #define TARGET_LITTLE_SYM i386_elf32_vec
4407 #define TARGET_LITTLE_NAME "elf32-i386"
4408 #define ELF_ARCH bfd_arch_i386
4409 #define ELF_TARGET_ID I386_ELF_DATA
4410 #define ELF_MACHINE_CODE EM_386
4411 #define ELF_MAXPAGESIZE 0x1000
4412
4413 #define elf_backend_can_gc_sections 1
4414 #define elf_backend_can_refcount 1
4415 #define elf_backend_want_got_plt 1
4416 #define elf_backend_plt_readonly 1
4417 #define elf_backend_want_plt_sym 0
4418 #define elf_backend_got_header_size 12
4419 #define elf_backend_plt_alignment 4
4420 #define elf_backend_dtrel_excludes_plt 1
4421 #define elf_backend_extern_protected_data 1
4422 #define elf_backend_caches_rawsize 1
4423 #define elf_backend_want_dynrelro 1
4424
4425 /* Support RELA for objdump of prelink objects. */
4426 #define elf_info_to_howto elf_i386_info_to_howto_rel
4427 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4428
4429 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4430 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
4431 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
4432 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
4433
4434 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4435 #define elf_backend_always_size_sections elf_i386_always_size_sections
4436 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
4437 #define elf_backend_fake_sections elf_i386_fake_sections
4438 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4439 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4440 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
4441 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
4442 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
4443 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
4444 #define elf_backend_relocate_section elf_i386_relocate_section
4445 #define elf_backend_setup_gnu_properties elf_i386_link_setup_gnu_properties
4446 #define elf_backend_hide_symbol _bfd_x86_elf_hide_symbol
4447
4448 #define elf_backend_linux_prpsinfo32_ugid16 true
4449
4450 #define elf32_bed elf32_i386_bed
4451
4452 #include "elf32-target.h"
4453
4454 /* FreeBSD support. */
4455
4456 #undef TARGET_LITTLE_SYM
4457 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
4458 #undef TARGET_LITTLE_NAME
4459 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
4460 #undef ELF_OSABI
4461 #define ELF_OSABI ELFOSABI_FREEBSD
4462
4463 /* The kernel recognizes executables as valid only if they carry a
4464 "FreeBSD" label in the ELF header. So we put this label on all
4465 executables and (for simplicity) also all other object files. */
4466
4467 static bool
4468 elf_i386_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
4469 {
4470 if (!_bfd_elf_init_file_header (abfd, info))
4471 return false;
4472
4473 #ifdef OLD_FREEBSD_ABI_LABEL
4474 {
4475 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4476 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4477 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
4478 }
4479 #endif
4480 return true;
4481 }
4482
4483 #undef elf_backend_init_file_header
4484 #define elf_backend_init_file_header elf_i386_fbsd_init_file_header
4485 #undef elf32_bed
4486 #define elf32_bed elf32_i386_fbsd_bed
4487
4488 #undef elf_backend_add_symbol_hook
4489
4490 #include "elf32-target.h"
4491
4492 #undef elf_backend_init_file_header
4493
4494 /* Solaris 2. */
4495
4496 #undef TARGET_LITTLE_SYM
4497 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
4498 #undef TARGET_LITTLE_NAME
4499 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
4500
4501 #undef ELF_TARGET_OS
4502 #define ELF_TARGET_OS is_solaris
4503
4504 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4505 objects won't be recognized. */
4506 #undef ELF_OSABI
4507
4508 #undef elf32_bed
4509 #define elf32_bed elf32_i386_sol2_bed
4510
4511 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
4512 boundary. */
4513 #undef elf_backend_static_tls_alignment
4514 #define elf_backend_static_tls_alignment 8
4515
4516 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4517
4518 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4519 File, p.63. */
4520 #undef elf_backend_want_plt_sym
4521 #define elf_backend_want_plt_sym 1
4522
4523 #undef elf_backend_strtab_flags
4524 #define elf_backend_strtab_flags SHF_STRINGS
4525
4526 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
4527 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
4528 FALSE otherwise. ISECTION is the best guess matching section from the
4529 input bfd IBFD, but it might be NULL. */
4530
4531 static bool
4532 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
4533 bfd *obfd ATTRIBUTE_UNUSED,
4534 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
4535 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
4536 {
4537 /* PR 19938: FIXME: Need to add code for setting the sh_info
4538 and sh_link fields of Solaris specific section types. */
4539 return false;
4540
4541 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
4542 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
4543
4544 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
4545
4546 The following values should be set:
4547
4548 Type Link Info
4549 -----------------------------------------------------------------------------
4550 SHT_SUNW_ancillary The section header index of 0
4551 [0x6fffffee] the associated string table.
4552
4553 SHT_SUNW_capinfo The section header index of For a dynamic object, the
4554 [0x6ffffff0] the associated symbol table. section header index of
4555 the associated
4556 SHT_SUNW_capchain table,
4557 otherwise 0.
4558
4559 SHT_SUNW_symsort The section header index of 0
4560 [0x6ffffff1] the associated symbol table.
4561
4562 SHT_SUNW_tlssort The section header index of 0
4563 [0x6ffffff2] the associated symbol table.
4564
4565 SHT_SUNW_LDYNSYM The section header index of One greater than the
4566 [0x6ffffff3] the associated string table. symbol table index of the
4567 This index is the same string last local symbol,
4568 table used by the SHT_DYNSYM STB_LOCAL. Since
4569 section. SHT_SUNW_LDYNSYM only
4570 contains local symbols,
4571 sh_info is equivalent to
4572 the number of symbols in
4573 the table.
4574
4575 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
4576 [0x6ffffff5] the section header index of to named strings, the
4577 the associated section header index of
4578 SHT_SUNW_capinfo table, the associated string
4579 otherwise 0. table, otherwise 0.
4580
4581 SHT_SUNW_move The section header index of 0
4582 [0x6ffffffa] the associated symbol table.
4583
4584 SHT_SUNW_COMDAT 0 0
4585 [0x6ffffffb]
4586
4587 SHT_SUNW_syminfo The section header index of The section header index
4588 [0x6ffffffc] the associated symbol table. of the associated
4589 .dynamic section.
4590
4591 SHT_SUNW_verdef The section header index of The number of version
4592 [0x6ffffffd] the associated string table. definitions within the
4593 section.
4594
4595 SHT_SUNW_verneed The section header index of The number of version
4596 [0x6ffffffe] the associated string table. dependencies within the
4597 section.
4598
4599 SHT_SUNW_versym The section header index of 0
4600 [0x6fffffff] the associated symbol table. */
4601 }
4602
4603 #undef elf_backend_copy_special_section_fields
4604 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
4605
4606 #include "elf32-target.h"
4607
4608 /* Intel MCU support. */
4609
4610 static bool
4611 elf32_iamcu_elf_object_p (bfd *abfd)
4612 {
4613 /* Set the right machine number for an IAMCU elf32 file. */
4614 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
4615 return true;
4616 }
4617
4618 #undef TARGET_LITTLE_SYM
4619 #define TARGET_LITTLE_SYM iamcu_elf32_vec
4620 #undef TARGET_LITTLE_NAME
4621 #define TARGET_LITTLE_NAME "elf32-iamcu"
4622 #undef ELF_ARCH
4623 #define ELF_ARCH bfd_arch_iamcu
4624
4625 #undef ELF_MACHINE_CODE
4626 #define ELF_MACHINE_CODE EM_IAMCU
4627
4628 #undef ELF_TARGET_OS
4629 #undef ELF_OSABI
4630
4631 #undef elf32_bed
4632 #define elf32_bed elf32_iamcu_bed
4633
4634 #undef elf_backend_object_p
4635 #define elf_backend_object_p elf32_iamcu_elf_object_p
4636
4637 #undef elf_backend_static_tls_alignment
4638
4639 #undef elf_backend_want_plt_sym
4640 #define elf_backend_want_plt_sym 0
4641
4642 #undef elf_backend_strtab_flags
4643 #undef elf_backend_copy_special_section_fields
4644
4645 #include "elf32-target.h"
4646
4647 /* Restore defaults. */
4648 #undef ELF_ARCH
4649 #define ELF_ARCH bfd_arch_i386
4650 #undef ELF_MACHINE_CODE
4651 #define ELF_MACHINE_CODE EM_386
4652 #undef elf_backend_object_p
4653
4654 /* VxWorks support. */
4655
4656 #undef TARGET_LITTLE_SYM
4657 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
4658 #undef TARGET_LITTLE_NAME
4659 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
4660 #undef ELF_OSABI
4661 #undef ELF_MAXPAGESIZE
4662 #define ELF_MAXPAGESIZE 0x1000
4663 #undef elf_backend_plt_alignment
4664 #define elf_backend_plt_alignment 4
4665
4666 #undef ELF_TARGET_OS
4667 #define ELF_TARGET_OS is_vxworks
4668
4669 #undef elf_backend_relocs_compatible
4670 #undef elf_backend_add_symbol_hook
4671 #define elf_backend_add_symbol_hook \
4672 elf_vxworks_add_symbol_hook
4673 #undef elf_backend_link_output_symbol_hook
4674 #define elf_backend_link_output_symbol_hook \
4675 elf_vxworks_link_output_symbol_hook
4676 #undef elf_backend_emit_relocs
4677 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
4678 #undef elf_backend_final_write_processing
4679 #define elf_backend_final_write_processing \
4680 elf_vxworks_final_write_processing
4681 #undef elf_backend_static_tls_alignment
4682
4683 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4684 define it. */
4685 #undef elf_backend_want_plt_sym
4686 #define elf_backend_want_plt_sym 1
4687
4688 #undef elf32_bed
4689 #define elf32_bed elf32_i386_vxworks_bed
4690
4691 #include "elf32-target.h"
blckswans binutils fork