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