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