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