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