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