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