1/* Intel 80386/80486-specific support for 32-bit ELF
2   Copyright (C) 1993-2020 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 "elfxx-x86.h"
22#include "elf-vxworks.h"
23#include "dwarf2.h"
24#include "opcode/i386.h"
25
26/* 386 uses REL relocations instead of RELA.  */
27#define USE_REL	1
28
29#include "elf/i386.h"
30
31static reloc_howto_type elf_howto_table[]=
32{
33  HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
34	bfd_elf_generic_reloc, "R_386_NONE",
35	TRUE, 0x00000000, 0x00000000, FALSE),
36  HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37	bfd_elf_generic_reloc, "R_386_32",
38	TRUE, 0xffffffff, 0xffffffff, FALSE),
39  HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
40	bfd_elf_generic_reloc, "R_386_PC32",
41	TRUE, 0xffffffff, 0xffffffff, TRUE),
42  HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
43	bfd_elf_generic_reloc, "R_386_GOT32",
44	TRUE, 0xffffffff, 0xffffffff, FALSE),
45  HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
46	bfd_elf_generic_reloc, "R_386_PLT32",
47	TRUE, 0xffffffff, 0xffffffff, TRUE),
48  HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
49	bfd_elf_generic_reloc, "R_386_COPY",
50	TRUE, 0xffffffff, 0xffffffff, FALSE),
51  HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
52	bfd_elf_generic_reloc, "R_386_GLOB_DAT",
53	TRUE, 0xffffffff, 0xffffffff, FALSE),
54  HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
55	bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
56	TRUE, 0xffffffff, 0xffffffff, FALSE),
57  HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
58	bfd_elf_generic_reloc, "R_386_RELATIVE",
59	TRUE, 0xffffffff, 0xffffffff, FALSE),
60  HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
61	bfd_elf_generic_reloc, "R_386_GOTOFF",
62	TRUE, 0xffffffff, 0xffffffff, FALSE),
63  HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
64	bfd_elf_generic_reloc, "R_386_GOTPC",
65	TRUE, 0xffffffff, 0xffffffff, TRUE),
66
67  /* We have a gap in the reloc numbers here.
68     R_386_standard counts the number up to this point, and
69     R_386_ext_offset is the value to subtract from a reloc type of
70     R_386_16 thru R_386_PC8 to form an index into this table.  */
71#define R_386_standard (R_386_GOTPC + 1)
72#define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
73
74  /* These relocs are a GNU extension.  */
75  HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
76	bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
77	TRUE, 0xffffffff, 0xffffffff, FALSE),
78  HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
79	bfd_elf_generic_reloc, "R_386_TLS_IE",
80	TRUE, 0xffffffff, 0xffffffff, FALSE),
81  HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
82	bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
83	TRUE, 0xffffffff, 0xffffffff, FALSE),
84  HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
85	bfd_elf_generic_reloc, "R_386_TLS_LE",
86	TRUE, 0xffffffff, 0xffffffff, FALSE),
87  HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
88	bfd_elf_generic_reloc, "R_386_TLS_GD",
89	TRUE, 0xffffffff, 0xffffffff, FALSE),
90  HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
91	bfd_elf_generic_reloc, "R_386_TLS_LDM",
92	TRUE, 0xffffffff, 0xffffffff, FALSE),
93  HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
94	bfd_elf_generic_reloc, "R_386_16",
95	TRUE, 0xffff, 0xffff, FALSE),
96  HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
97	bfd_elf_generic_reloc, "R_386_PC16",
98	TRUE, 0xffff, 0xffff, TRUE),
99  HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
100	bfd_elf_generic_reloc, "R_386_8",
101	TRUE, 0xff, 0xff, FALSE),
102  HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
103	bfd_elf_generic_reloc, "R_386_PC8",
104	TRUE, 0xff, 0xff, TRUE),
105
106#define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
107#define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
108  /* These are common with Solaris TLS implementation.  */
109  HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
110	bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
111	TRUE, 0xffffffff, 0xffffffff, FALSE),
112  HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
113	bfd_elf_generic_reloc, "R_386_TLS_IE_32",
114	TRUE, 0xffffffff, 0xffffffff, FALSE),
115  HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
116	bfd_elf_generic_reloc, "R_386_TLS_LE_32",
117	TRUE, 0xffffffff, 0xffffffff, FALSE),
118  HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
119	bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
120	TRUE, 0xffffffff, 0xffffffff, FALSE),
121  HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
122	bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
123	TRUE, 0xffffffff, 0xffffffff, FALSE),
124  HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
125	bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
126	TRUE, 0xffffffff, 0xffffffff, FALSE),
127  HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
128	bfd_elf_generic_reloc, "R_386_SIZE32",
129	TRUE, 0xffffffff, 0xffffffff, FALSE),
130  HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
131	bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
132	TRUE, 0xffffffff, 0xffffffff, FALSE),
133  HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
134	bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
135	FALSE, 0, 0, FALSE),
136  HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
137	bfd_elf_generic_reloc, "R_386_TLS_DESC",
138	TRUE, 0xffffffff, 0xffffffff, FALSE),
139  HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
140	bfd_elf_generic_reloc, "R_386_IRELATIVE",
141	TRUE, 0xffffffff, 0xffffffff, FALSE),
142  HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
143	bfd_elf_generic_reloc, "R_386_GOT32X",
144	TRUE, 0xffffffff, 0xffffffff, FALSE),
145
146  /* Another gap.  */
147#define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
148#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
149
150/* GNU extension to record C++ vtable hierarchy.  */
151  HOWTO (R_386_GNU_VTINHERIT,	/* type */
152	 0,			/* rightshift */
153	 2,			/* size (0 = byte, 1 = short, 2 = long) */
154	 0,			/* bitsize */
155	 FALSE,			/* pc_relative */
156	 0,			/* bitpos */
157	 complain_overflow_dont, /* complain_on_overflow */
158	 NULL,			/* special_function */
159	 "R_386_GNU_VTINHERIT",	/* name */
160	 FALSE,			/* partial_inplace */
161	 0,			/* src_mask */
162	 0,			/* dst_mask */
163	 FALSE),		/* pcrel_offset */
164
165/* GNU extension to record C++ vtable member usage.  */
166  HOWTO (R_386_GNU_VTENTRY,	/* type */
167	 0,			/* rightshift */
168	 2,			/* size (0 = byte, 1 = short, 2 = long) */
169	 0,			/* bitsize */
170	 FALSE,			/* pc_relative */
171	 0,			/* bitpos */
172	 complain_overflow_dont, /* complain_on_overflow */
173	 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
174	 "R_386_GNU_VTENTRY",	/* name */
175	 FALSE,			/* partial_inplace */
176	 0,			/* src_mask */
177	 0,			/* dst_mask */
178	 FALSE)			/* pcrel_offset */
179
180#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
181
182};
183
184#define X86_PCREL_TYPE_P(TYPE) ((TYPE) == R_386_PC32)
185
186#define X86_SIZE_TYPE_P(TYPE) ((TYPE) == R_386_SIZE32)
187
188#ifdef DEBUG_GEN_RELOC
189#define TRACE(str) \
190  fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
191#else
192#define TRACE(str)
193#endif
194
195static reloc_howto_type *
196elf_i386_reloc_type_lookup (bfd *abfd,
197			    bfd_reloc_code_real_type code)
198{
199  switch (code)
200    {
201    case BFD_RELOC_NONE:
202      TRACE ("BFD_RELOC_NONE");
203      return &elf_howto_table[R_386_NONE];
204
205    case BFD_RELOC_32:
206      TRACE ("BFD_RELOC_32");
207      return &elf_howto_table[R_386_32];
208
209    case BFD_RELOC_CTOR:
210      TRACE ("BFD_RELOC_CTOR");
211      return &elf_howto_table[R_386_32];
212
213    case BFD_RELOC_32_PCREL:
214      TRACE ("BFD_RELOC_PC32");
215      return &elf_howto_table[R_386_PC32];
216
217    case BFD_RELOC_386_GOT32:
218      TRACE ("BFD_RELOC_386_GOT32");
219      return &elf_howto_table[R_386_GOT32];
220
221    case BFD_RELOC_386_PLT32:
222      TRACE ("BFD_RELOC_386_PLT32");
223      return &elf_howto_table[R_386_PLT32];
224
225    case BFD_RELOC_386_COPY:
226      TRACE ("BFD_RELOC_386_COPY");
227      return &elf_howto_table[R_386_COPY];
228
229    case BFD_RELOC_386_GLOB_DAT:
230      TRACE ("BFD_RELOC_386_GLOB_DAT");
231      return &elf_howto_table[R_386_GLOB_DAT];
232
233    case BFD_RELOC_386_JUMP_SLOT:
234      TRACE ("BFD_RELOC_386_JUMP_SLOT");
235      return &elf_howto_table[R_386_JUMP_SLOT];
236
237    case BFD_RELOC_386_RELATIVE:
238      TRACE ("BFD_RELOC_386_RELATIVE");
239      return &elf_howto_table[R_386_RELATIVE];
240
241    case BFD_RELOC_386_GOTOFF:
242      TRACE ("BFD_RELOC_386_GOTOFF");
243      return &elf_howto_table[R_386_GOTOFF];
244
245    case BFD_RELOC_386_GOTPC:
246      TRACE ("BFD_RELOC_386_GOTPC");
247      return &elf_howto_table[R_386_GOTPC];
248
249      /* These relocs are a GNU extension.  */
250    case BFD_RELOC_386_TLS_TPOFF:
251      TRACE ("BFD_RELOC_386_TLS_TPOFF");
252      return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
253
254    case BFD_RELOC_386_TLS_IE:
255      TRACE ("BFD_RELOC_386_TLS_IE");
256      return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
257
258    case BFD_RELOC_386_TLS_GOTIE:
259      TRACE ("BFD_RELOC_386_TLS_GOTIE");
260      return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
261
262    case BFD_RELOC_386_TLS_LE:
263      TRACE ("BFD_RELOC_386_TLS_LE");
264      return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
265
266    case BFD_RELOC_386_TLS_GD:
267      TRACE ("BFD_RELOC_386_TLS_GD");
268      return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
269
270    case BFD_RELOC_386_TLS_LDM:
271      TRACE ("BFD_RELOC_386_TLS_LDM");
272      return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
273
274    case BFD_RELOC_16:
275      TRACE ("BFD_RELOC_16");
276      return &elf_howto_table[R_386_16 - R_386_ext_offset];
277
278    case BFD_RELOC_16_PCREL:
279      TRACE ("BFD_RELOC_16_PCREL");
280      return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
281
282    case BFD_RELOC_8:
283      TRACE ("BFD_RELOC_8");
284      return &elf_howto_table[R_386_8 - R_386_ext_offset];
285
286    case BFD_RELOC_8_PCREL:
287      TRACE ("BFD_RELOC_8_PCREL");
288      return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
289
290    /* Common with Sun TLS implementation.  */
291    case BFD_RELOC_386_TLS_LDO_32:
292      TRACE ("BFD_RELOC_386_TLS_LDO_32");
293      return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
294
295    case BFD_RELOC_386_TLS_IE_32:
296      TRACE ("BFD_RELOC_386_TLS_IE_32");
297      return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
298
299    case BFD_RELOC_386_TLS_LE_32:
300      TRACE ("BFD_RELOC_386_TLS_LE_32");
301      return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
302
303    case BFD_RELOC_386_TLS_DTPMOD32:
304      TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
305      return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
306
307    case BFD_RELOC_386_TLS_DTPOFF32:
308      TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
309      return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
310
311    case BFD_RELOC_386_TLS_TPOFF32:
312      TRACE ("BFD_RELOC_386_TLS_TPOFF32");
313      return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
314
315    case BFD_RELOC_SIZE32:
316      TRACE ("BFD_RELOC_SIZE32");
317      return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
318
319    case BFD_RELOC_386_TLS_GOTDESC:
320      TRACE ("BFD_RELOC_386_TLS_GOTDESC");
321      return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
322
323    case BFD_RELOC_386_TLS_DESC_CALL:
324      TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
325      return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
326
327    case BFD_RELOC_386_TLS_DESC:
328      TRACE ("BFD_RELOC_386_TLS_DESC");
329      return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
330
331    case BFD_RELOC_386_IRELATIVE:
332      TRACE ("BFD_RELOC_386_IRELATIVE");
333      return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
334
335    case BFD_RELOC_386_GOT32X:
336      TRACE ("BFD_RELOC_386_GOT32X");
337      return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
338
339    case BFD_RELOC_VTABLE_INHERIT:
340      TRACE ("BFD_RELOC_VTABLE_INHERIT");
341      return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
342
343    case BFD_RELOC_VTABLE_ENTRY:
344      TRACE ("BFD_RELOC_VTABLE_ENTRY");
345      return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
346
347    default:
348      TRACE ("Unknown");
349      /* xgettext:c-format */
350      _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
351			  abfd, (int) code);
352      bfd_set_error (bfd_error_bad_value);
353      return NULL;
354    }
355}
356
357static reloc_howto_type *
358elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
359			    const char *r_name)
360{
361  unsigned int i;
362
363  for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
364    if (elf_howto_table[i].name != NULL
365	&& strcasecmp (elf_howto_table[i].name, r_name) == 0)
366      return &elf_howto_table[i];
367
368  return NULL;
369}
370
371static reloc_howto_type *
372elf_i386_rtype_to_howto (unsigned r_type)
373{
374  unsigned int indx;
375
376  if ((indx = r_type) >= R_386_standard
377      && ((indx = r_type - R_386_ext_offset) - R_386_standard
378	  >= R_386_ext - R_386_standard)
379      && ((indx = r_type - R_386_tls_offset) - R_386_ext
380	  >= R_386_ext2 - R_386_ext)
381      && ((indx = r_type - R_386_vt_offset) - R_386_ext2
382	  >= R_386_vt - R_386_ext2))
383      return NULL;
384  /* PR 17512: file: 0f67f69d.  */
385  if (elf_howto_table [indx].type != r_type)
386    return NULL;
387  return &elf_howto_table[indx];
388}
389
390static bfd_boolean
391elf_i386_info_to_howto_rel (bfd *abfd,
392			    arelent *cache_ptr,
393			    Elf_Internal_Rela *dst)
394{
395  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
396
397  if ((cache_ptr->howto = elf_i386_rtype_to_howto (r_type)) == NULL)
398    {
399      /* xgettext:c-format */
400      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
401			  abfd, r_type);
402      bfd_set_error (bfd_error_bad_value);
403      return FALSE;
404    }
405
406  return TRUE;
407}
408
409/* Return whether a symbol name implies a local label.  The UnixWare
410   2.1 cc generates temporary symbols that start with .X, so we
411   recognize them here.  FIXME: do other SVR4 compilers also use .X?.
412   If so, we should move the .X recognition into
413   _bfd_elf_is_local_label_name.  */
414
415static bfd_boolean
416elf_i386_is_local_label_name (bfd *abfd, const char *name)
417{
418  if (name[0] == '.' && name[1] == 'X')
419    return TRUE;
420
421  return _bfd_elf_is_local_label_name (abfd, name);
422}
423
424/* Support for core dump NOTE sections.  */
425
426static bfd_boolean
427elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
428{
429  int offset;
430  size_t size;
431
432  if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
433    {
434      int pr_version = bfd_get_32 (abfd, note->descdata);
435
436      if (pr_version != 1)
437	return FALSE;
438
439      /* pr_cursig */
440      elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
441
442      /* pr_pid */
443      elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
444
445      /* pr_reg */
446      offset = 28;
447      size = bfd_get_32 (abfd, note->descdata + 8);
448    }
449  else
450    {
451      switch (note->descsz)
452	{
453	default:
454	  return FALSE;
455
456	case 144:		/* Linux/i386 */
457	  /* pr_cursig */
458	  elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
459
460	  /* pr_pid */
461	  elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
462
463	  /* pr_reg */
464	  offset = 72;
465	  size = 68;
466
467	  break;
468	}
469    }
470
471  /* Make a ".reg/999" section.  */
472  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
473					  size, note->descpos + offset);
474}
475
476static bfd_boolean
477elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
478{
479  if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
480    {
481      int pr_version = bfd_get_32 (abfd, note->descdata);
482
483      if (pr_version != 1)
484	return FALSE;
485
486      elf_tdata (abfd)->core->program
487	= _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
488      elf_tdata (abfd)->core->command
489	= _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
490    }
491  else
492    {
493      switch (note->descsz)
494	{
495	default:
496	  return FALSE;
497
498	case 124:		/* Linux/i386 elf_prpsinfo.  */
499	  elf_tdata (abfd)->core->pid
500	    = bfd_get_32 (abfd, note->descdata + 12);
501	  elf_tdata (abfd)->core->program
502	    = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
503	  elf_tdata (abfd)->core->command
504	    = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
505	}
506    }
507
508  /* Note that for some reason, a spurious space is tacked
509     onto the end of the args in some (at least one anyway)
510     implementations, so strip it off if it exists.  */
511  {
512    char *command = elf_tdata (abfd)->core->command;
513    int n = strlen (command);
514
515    if (0 < n && command[n - 1] == ' ')
516      command[n - 1] = '\0';
517  }
518
519  return TRUE;
520}
521
522/* Functions for the i386 ELF linker.
523
524   In order to gain some understanding of code in this file without
525   knowing all the intricate details of the linker, note the
526   following:
527
528   Functions named elf_i386_* are called by external routines, other
529   functions are only called locally.  elf_i386_* functions appear
530   in this file more or less in the order in which they are called
531   from external routines.  eg. elf_i386_check_relocs is called
532   early in the link process, elf_i386_finish_dynamic_sections is
533   one of the last functions.  */
534
535/* The size in bytes of an entry in the lazy procedure linkage table.  */
536
537#define LAZY_PLT_ENTRY_SIZE 16
538
539/* The size in bytes of an entry in the non-lazy procedure linkage
540   table.  */
541
542#define NON_LAZY_PLT_ENTRY_SIZE 8
543
544/* The first entry in an absolute lazy procedure linkage table looks
545   like this.  See the SVR4 ABI i386 supplement to see how this works.
546   Will be padded to LAZY_PLT_ENTRY_SIZE with lazy_plt->plt0_pad_byte.  */
547
548static const bfd_byte elf_i386_lazy_plt0_entry[12] =
549{
550  0xff, 0x35,	/* pushl contents of address */
551  0, 0, 0, 0,	/* replaced with address of .got + 4.  */
552  0xff, 0x25,	/* jmp indirect */
553  0, 0, 0, 0	/* replaced with address of .got + 8.  */
554};
555
556/* Subsequent entries in an absolute lazy procedure linkage table look
557   like this.  */
558
559static const bfd_byte elf_i386_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
560{
561  0xff, 0x25,	/* jmp indirect */
562  0, 0, 0, 0,	/* replaced with address of this symbol in .got.  */
563  0x68,		/* pushl immediate */
564  0, 0, 0, 0,	/* replaced with offset into relocation table.  */
565  0xe9,		/* jmp relative */
566  0, 0, 0, 0	/* replaced with offset to start of .plt.  */
567};
568
569/* The first entry in a PIC lazy procedure linkage table look like
570   this.  Will be padded to LAZY_PLT_ENTRY_SIZE with
571   lazy_plt->plt0_pad_byte.  */
572
573static const bfd_byte elf_i386_pic_lazy_plt0_entry[12] =
574{
575  0xff, 0xb3, 4, 0, 0, 0,	/* pushl 4(%ebx) */
576  0xff, 0xa3, 8, 0, 0, 0	/* jmp *8(%ebx) */
577};
578
579/* Subsequent entries in a PIC lazy procedure linkage table look like
580   this.  */
581
582static const bfd_byte elf_i386_pic_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
583{
584  0xff, 0xa3,	/* jmp *offset(%ebx) */
585  0, 0, 0, 0,	/* replaced with offset of this symbol in .got.  */
586  0x68,		/* pushl immediate */
587  0, 0, 0, 0,	/* replaced with offset into relocation table.  */
588  0xe9,		/* jmp relative */
589  0, 0, 0, 0	/* replaced with offset to start of .plt.  */
590};
591
592/* Entries in the non-lazy procedure linkage table look like this.  */
593
594static const bfd_byte elf_i386_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
595{
596  0xff, 0x25,	/* jmp indirect */
597  0, 0, 0, 0,	/* replaced with offset of this symbol in .got.  */
598  0x66, 0x90	/* xchg %ax,%ax  */
599};
600
601/* Entries in the PIC non-lazy procedure linkage table look like
602   this.  */
603
604static const bfd_byte elf_i386_pic_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
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/* The first entry in an absolute IBT-enabled lazy procedure linkage
612   table looks like this.  */
613
614static const bfd_byte elf_i386_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
615{
616  0xff, 0x35, 0, 0, 0, 0,	/* pushl GOT[1]	      */
617  0xff, 0x25, 0, 0, 0, 0,	/* jmp *GOT[2]	      */
618  0x0f, 0x1f, 0x40, 0x00	/* nopl 0(%rax)	      */
619};
620
621/* Subsequent entries for an absolute IBT-enabled lazy procedure linkage
622   table look like this.  Subsequent entries for a PIC IBT-enabled lazy
623   procedure linkage table are the same.  */
624
625static const bfd_byte elf_i386_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
626{
627  0xf3, 0x0f, 0x1e, 0xfb,	/* endbr32		      */
628  0x68, 0, 0, 0, 0,		/* pushl immediate	      */
629  0xe9, 0, 0, 0, 0,		/* jmp relative		      */
630  0x66, 0x90			/* xchg %ax,%ax		      */
631};
632
633/* The first entry in a PIC IBT-enabled lazy procedure linkage table
634   look like.  */
635
636static const bfd_byte elf_i386_pic_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
637{
638  0xff, 0xb3, 4, 0, 0, 0,	/* pushl 4(%ebx)      */
639  0xff, 0xa3, 8, 0, 0, 0,	/* jmp *8(%ebx)	      */
640  0x0f, 0x1f, 0x40, 0x00	/* nopl 0(%rax)	      */
641};
642
643/* Entries for branches with IBT-enabled in the absolute non-lazey
644   procedure linkage table look like this.  They have the same size
645   as the lazy PLT entry.  */
646
647static const bfd_byte elf_i386_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
648{
649  0xf3, 0x0f, 0x1e, 0xfb,	     /* endbr32		      */
650  0xff, 0x25, 0, 0, 0, 0,	     /* jmp *name@GOT	      */
651  0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
652};
653
654/* Entries for branches with IBT-enabled in the PIC non-lazey procedure
655   linkage table look like this.  They have the same size as the lazy
656   PLT entry.  */
657
658static const bfd_byte elf_i386_pic_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
659{
660  0xf3, 0x0f, 0x1e, 0xfb,	     /* endbr32		      */
661  0xff, 0xa3, 0, 0, 0, 0,	     /* jmp *name@GOT(%ebx)   */
662  0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
663};
664
665/* .eh_frame covering the lazy .plt section.  */
666
667static const bfd_byte elf_i386_eh_frame_lazy_plt[] =
668{
669  PLT_CIE_LENGTH, 0, 0, 0,	/* CIE length */
670  0, 0, 0, 0,			/* CIE ID */
671  1,				/* CIE version */
672  'z', 'R', 0,			/* Augmentation string */
673  1,				/* Code alignment factor */
674  0x7c,				/* Data alignment factor */
675  8,				/* Return address column */
676  1,				/* Augmentation size */
677  DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
678  DW_CFA_def_cfa, 4, 4,		/* DW_CFA_def_cfa: r4 (esp) ofs 4 */
679  DW_CFA_offset + 8, 1,		/* DW_CFA_offset: r8 (eip) at cfa-4 */
680  DW_CFA_nop, DW_CFA_nop,
681
682  PLT_FDE_LENGTH, 0, 0, 0,	/* FDE length */
683  PLT_CIE_LENGTH + 8, 0, 0, 0,	/* CIE pointer */
684  0, 0, 0, 0,			/* R_386_PC32 .plt goes here */
685  0, 0, 0, 0,			/* .plt size goes here */
686  0,				/* Augmentation size */
687  DW_CFA_def_cfa_offset, 8,	/* DW_CFA_def_cfa_offset: 8 */
688  DW_CFA_advance_loc + 6,	/* DW_CFA_advance_loc: 6 to __PLT__+6 */
689  DW_CFA_def_cfa_offset, 12,	/* DW_CFA_def_cfa_offset: 12 */
690  DW_CFA_advance_loc + 10,	/* DW_CFA_advance_loc: 10 to __PLT__+16 */
691  DW_CFA_def_cfa_expression,	/* DW_CFA_def_cfa_expression */
692  11,				/* Block length */
693  DW_OP_breg4, 4,		/* DW_OP_breg4 (esp): 4 */
694  DW_OP_breg8, 0,		/* DW_OP_breg8 (eip): 0 */
695  DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
696  DW_OP_lit2, DW_OP_shl, DW_OP_plus,
697  DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
698};
699
700/* .eh_frame covering the lazy .plt section with IBT-enabled.  */
701
702static const bfd_byte elf_i386_eh_frame_lazy_ibt_plt[] =
703{
704  PLT_CIE_LENGTH, 0, 0, 0,	/* CIE length */
705  0, 0, 0, 0,			/* CIE ID */
706  1,				/* CIE version */
707  'z', 'R', 0,			/* Augmentation string */
708  1,				/* Code alignment factor */
709  0x7c,				/* Data alignment factor */
710  8,				/* Return address column */
711  1,				/* Augmentation size */
712  DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
713  DW_CFA_def_cfa, 4, 4,		/* DW_CFA_def_cfa: r4 (esp) ofs 4 */
714  DW_CFA_offset + 8, 1,		/* DW_CFA_offset: r8 (eip) at cfa-4 */
715  DW_CFA_nop, DW_CFA_nop,
716
717  PLT_FDE_LENGTH, 0, 0, 0,	/* FDE length */
718  PLT_CIE_LENGTH + 8, 0, 0, 0,	/* CIE pointer */
719  0, 0, 0, 0,			/* R_386_PC32 .plt goes here */
720  0, 0, 0, 0,			/* .plt size goes here */
721  0,				/* Augmentation size */
722  DW_CFA_def_cfa_offset, 8,	/* DW_CFA_def_cfa_offset: 8 */
723  DW_CFA_advance_loc + 6,	/* DW_CFA_advance_loc: 6 to __PLT__+6 */
724  DW_CFA_def_cfa_offset, 12,	/* DW_CFA_def_cfa_offset: 12 */
725  DW_CFA_advance_loc + 10,	/* DW_CFA_advance_loc: 10 to __PLT__+16 */
726  DW_CFA_def_cfa_expression,	/* DW_CFA_def_cfa_expression */
727  11,				/* Block length */
728  DW_OP_breg4, 4,		/* DW_OP_breg4 (esp): 4 */
729  DW_OP_breg8, 0,		/* DW_OP_breg8 (eip): 0 */
730  DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
731  DW_OP_lit2, DW_OP_shl, DW_OP_plus,
732  DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
733};
734
735/* .eh_frame covering the non-lazy .plt section.  */
736
737static const bfd_byte elf_i386_eh_frame_non_lazy_plt[] =
738{
739#define PLT_GOT_FDE_LENGTH		16
740  PLT_CIE_LENGTH, 0, 0, 0,	/* CIE length */
741  0, 0, 0, 0,			/* CIE ID */
742  1,				/* CIE version */
743  'z', 'R', 0,			/* Augmentation string */
744  1,				/* Code alignment factor */
745  0x7c,				/* Data alignment factor */
746  8,				/* Return address column */
747  1,				/* Augmentation size */
748  DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
749  DW_CFA_def_cfa, 4, 4,		/* DW_CFA_def_cfa: r4 (esp) ofs 4 */
750  DW_CFA_offset + 8, 1,		/* DW_CFA_offset: r8 (eip) at cfa-4 */
751  DW_CFA_nop, DW_CFA_nop,
752
753  PLT_GOT_FDE_LENGTH, 0, 0, 0,	/* FDE length */
754  PLT_CIE_LENGTH + 8, 0, 0, 0,	/* CIE pointer */
755  0, 0, 0, 0,			/* the start of non-lazy .plt goes here */
756  0, 0, 0, 0,			/* non-lazy .plt size goes here */
757  0,				/* Augmentation size */
758  DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
759};
760
761/* These are the standard parameters.  */
762static const struct elf_x86_lazy_plt_layout elf_i386_lazy_plt =
763  {
764    elf_i386_lazy_plt0_entry,		/* plt0_entry */
765    sizeof (elf_i386_lazy_plt0_entry),	/* plt0_entry_size */
766    elf_i386_lazy_plt_entry,		/* plt_entry */
767    LAZY_PLT_ENTRY_SIZE,		/* plt_entry_size */
768    NULL,				/* plt_tlsdesc_entry */
769    0,					/* plt_tlsdesc_entry_size*/
770    0,					/* plt_tlsdesc_got1_offset */
771    0,					/* plt_tlsdesc_got2_offset */
772    0,					/* plt_tlsdesc_got1_insn_end */
773    0,					/* plt_tlsdesc_got2_insn_end */
774    2,					/* plt0_got1_offset */
775    8,					/* plt0_got2_offset */
776    0,					/* plt0_got2_insn_end */
777    2,					/* plt_got_offset */
778    7,					/* plt_reloc_offset */
779    12,					/* plt_plt_offset */
780    0,					/* plt_got_insn_size */
781    0,					/* plt_plt_insn_end */
782    6,					/* plt_lazy_offset */
783    elf_i386_pic_lazy_plt0_entry,	/* pic_plt0_entry */
784    elf_i386_pic_lazy_plt_entry,	/* pic_plt_entry */
785    elf_i386_eh_frame_lazy_plt,		/* eh_frame_plt */
786    sizeof (elf_i386_eh_frame_lazy_plt) /* eh_frame_plt_size */
787  };
788
789static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_plt =
790  {
791    elf_i386_non_lazy_plt_entry,	/* plt_entry */
792    elf_i386_pic_non_lazy_plt_entry,	/* pic_plt_entry */
793    NON_LAZY_PLT_ENTRY_SIZE,		/* plt_entry_size */
794    2,					/* plt_got_offset */
795    0,					/* plt_got_insn_size */
796    elf_i386_eh_frame_non_lazy_plt,	/* eh_frame_plt */
797    sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
798  };
799
800static const struct elf_x86_lazy_plt_layout elf_i386_lazy_ibt_plt =
801  {
802    elf_i386_lazy_ibt_plt0_entry,	/* plt0_entry */
803    sizeof (elf_i386_lazy_ibt_plt0_entry), /* plt0_entry_size */
804    elf_i386_lazy_ibt_plt_entry,	/* plt_entry */
805    LAZY_PLT_ENTRY_SIZE,		/* plt_entry_size */
806    NULL,				/* plt_tlsdesc_entry */
807    0,					/* plt_tlsdesc_entry_size*/
808    0,					/* plt_tlsdesc_got1_offset */
809    0,					/* plt_tlsdesc_got2_offset */
810    0,					/* plt_tlsdesc_got1_insn_end */
811    0,					/* plt_tlsdesc_got2_insn_end */
812    2,					/* plt0_got1_offset */
813    8,					/* plt0_got2_offset */
814    0,					/* plt0_got2_insn_end */
815    4+2,				/* plt_got_offset */
816    4+1,				/* plt_reloc_offset */
817    4+6,				/* plt_plt_offset */
818    0,					/* plt_got_insn_size */
819    0,					/* plt_plt_insn_end */
820    0,					/* plt_lazy_offset */
821    elf_i386_pic_lazy_ibt_plt0_entry,	/* pic_plt0_entry */
822    elf_i386_lazy_ibt_plt_entry,	/* pic_plt_entry */
823    elf_i386_eh_frame_lazy_ibt_plt,	/* eh_frame_plt */
824    sizeof (elf_i386_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
825  };
826
827static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_ibt_plt =
828  {
829    elf_i386_non_lazy_ibt_plt_entry,	/* plt_entry */
830    elf_i386_pic_non_lazy_ibt_plt_entry,/* pic_plt_entry */
831    LAZY_PLT_ENTRY_SIZE,		/* plt_entry_size */
832    4+2,				/* plt_got_offset */
833    0,					/* plt_got_insn_size */
834    elf_i386_eh_frame_non_lazy_plt,	/* eh_frame_plt */
835    sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
836  };
837
838
839/* On VxWorks, the .rel.plt.unloaded section has absolute relocations
840   for the PLTResolve stub and then for each PLT entry.  */
841#define PLTRESOLVE_RELOCS_SHLIB 0
842#define PLTRESOLVE_RELOCS 2
843#define PLT_NON_JUMP_SLOT_RELOCS 2
844
845/* Return TRUE if the TLS access code sequence support transition
846   from R_TYPE.  */
847
848static bfd_boolean
849elf_i386_check_tls_transition (asection *sec,
850			       bfd_byte *contents,
851			       Elf_Internal_Shdr *symtab_hdr,
852			       struct elf_link_hash_entry **sym_hashes,
853			       unsigned int r_type,
854			       const Elf_Internal_Rela *rel,
855			       const Elf_Internal_Rela *relend)
856{
857  unsigned int val, type, reg;
858  unsigned long r_symndx;
859  struct elf_link_hash_entry *h;
860  bfd_vma offset;
861  bfd_byte *call;
862  bfd_boolean indirect_call;
863
864  offset = rel->r_offset;
865  switch (r_type)
866    {
867    case R_386_TLS_GD:
868    case R_386_TLS_LDM:
869      if (offset < 2 || (rel + 1) >= relend)
870	return FALSE;
871
872      indirect_call = FALSE;
873      call = contents + offset + 4;
874      val = *(call - 5);
875      type = *(call - 6);
876      if (r_type == R_386_TLS_GD)
877	{
878	  /* Check transition from GD access model.  Only
879		leal foo@tlsgd(,%ebx,1), %eax
880		call ___tls_get_addr@PLT
881	     or
882		leal foo@tlsgd(%ebx) %eax
883		call ___tls_get_addr@PLT
884		nop
885	     or
886		leal foo@tlsgd(%reg), %eax
887		call *___tls_get_addr@GOT(%reg)
888		which may be converted to
889		addr32 call ___tls_get_addr
890	     can transit to different access model.  */
891	  if ((offset + 10) > sec->size
892	      || (type != 0x8d && type != 0x04))
893	    return FALSE;
894
895	  if (type == 0x04)
896	    {
897	      /* leal foo@tlsgd(,%ebx,1), %eax
898		 call ___tls_get_addr@PLT  */
899	      if (offset < 3)
900		return FALSE;
901
902	      if (*(call - 7) != 0x8d
903		  || val != 0x1d
904		  || call[0] != 0xe8)
905		return FALSE;
906	    }
907	  else
908	    {
909	      /* This must be
910			leal foo@tlsgd(%ebx), %eax
911			call ___tls_get_addr@PLT
912			nop
913		 or
914			leal foo@tlsgd(%reg), %eax
915			call *___tls_get_addr@GOT(%reg)
916			which may be converted to
917			addr32 call ___tls_get_addr
918
919		 %eax can't be used as the GOT base register since it
920		 is used to pass parameter to ___tls_get_addr.  */
921	      reg = val & 7;
922	      if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
923		return FALSE;
924
925	      indirect_call = call[0] == 0xff;
926	      if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
927		  && !(call[0] == 0x67 && call[1] == 0xe8)
928		  && !(indirect_call
929		       && (call[1] & 0xf8) == 0x90
930		       && (call[1] & 0x7) == reg))
931		return FALSE;
932	    }
933	}
934      else
935	{
936	  /* Check transition from LD access model.  Only
937		leal foo@tlsldm(%ebx), %eax
938		call ___tls_get_addr@PLT
939	     or
940		leal foo@tlsldm(%reg), %eax
941		call *___tls_get_addr@GOT(%reg)
942		which may be converted to
943		addr32 call ___tls_get_addr
944	     can transit to different access model.  */
945	  if (type != 0x8d || (offset + 9) > sec->size)
946	    return FALSE;
947
948	  /* %eax can't be used as the GOT base register since it is
949	     used to pass parameter to ___tls_get_addr.  */
950	  reg = val & 7;
951	  if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
952	    return FALSE;
953
954	  indirect_call = call[0] == 0xff;
955	  if (!(reg == 3 && call[0] == 0xe8)
956	      && !(call[0] == 0x67 && call[1] == 0xe8)
957	      && !(indirect_call
958		   && (call[1] & 0xf8) == 0x90
959		   && (call[1] & 0x7) == reg))
960	    return FALSE;
961	}
962
963      r_symndx = ELF32_R_SYM (rel[1].r_info);
964      if (r_symndx < symtab_hdr->sh_info)
965	return FALSE;
966
967      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
968      if (h == NULL
969	  || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
970	return FALSE;
971      else if (indirect_call)
972	return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
973      else
974	return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
975		|| ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
976
977    case R_386_TLS_IE:
978      /* Check transition from IE access model:
979		movl foo@indntpoff(%rip), %eax
980		movl foo@indntpoff(%rip), %reg
981		addl foo@indntpoff(%rip), %reg
982       */
983
984      if (offset < 1 || (offset + 4) > sec->size)
985	return FALSE;
986
987      /* Check "movl foo@tpoff(%rip), %eax" first.  */
988      val = bfd_get_8 (abfd, contents + offset - 1);
989      if (val == 0xa1)
990	return TRUE;
991
992      if (offset < 2)
993	return FALSE;
994
995      /* Check movl|addl foo@tpoff(%rip), %reg.   */
996      type = bfd_get_8 (abfd, contents + offset - 2);
997      return ((type == 0x8b || type == 0x03)
998	      && (val & 0xc7) == 0x05);
999
1000    case R_386_TLS_GOTIE:
1001    case R_386_TLS_IE_32:
1002      /* Check transition from {IE_32,GOTIE} access model:
1003		subl foo@{tpoff,gontoff}(%reg1), %reg2
1004		movl foo@{tpoff,gontoff}(%reg1), %reg2
1005		addl foo@{tpoff,gontoff}(%reg1), %reg2
1006       */
1007
1008      if (offset < 2 || (offset + 4) > sec->size)
1009	return FALSE;
1010
1011      val = bfd_get_8 (abfd, contents + offset - 1);
1012      if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1013	return FALSE;
1014
1015      type = bfd_get_8 (abfd, contents + offset - 2);
1016      return type == 0x8b || type == 0x2b || type == 0x03;
1017
1018    case R_386_TLS_GOTDESC:
1019      /* Check transition from GDesc access model:
1020		leal x@tlsdesc(%ebx), %eax
1021
1022	 Make sure it's a leal adding ebx to a 32-bit offset
1023	 into any register, although it's probably almost always
1024	 going to be eax.  */
1025
1026      if (offset < 2 || (offset + 4) > sec->size)
1027	return FALSE;
1028
1029      if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1030	return FALSE;
1031
1032      val = bfd_get_8 (abfd, contents + offset - 1);
1033      return (val & 0xc7) == 0x83;
1034
1035    case R_386_TLS_DESC_CALL:
1036      /* Check transition from GDesc access model:
1037		call *x@tlsdesc(%eax)
1038       */
1039      if (offset + 2 <= sec->size)
1040	{
1041	  /* Make sure that it's a call *x@tlsdesc(%eax).  */
1042	  call = contents + offset;
1043	  return call[0] == 0xff && call[1] == 0x10;
1044	}
1045
1046      return FALSE;
1047
1048    default:
1049      abort ();
1050    }
1051}
1052
1053/* Return TRUE if the TLS access transition is OK or no transition
1054   will be performed.  Update R_TYPE if there is a transition.  */
1055
1056static bfd_boolean
1057elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1058			 asection *sec, bfd_byte *contents,
1059			 Elf_Internal_Shdr *symtab_hdr,
1060			 struct elf_link_hash_entry **sym_hashes,
1061			 unsigned int *r_type, int tls_type,
1062			 const Elf_Internal_Rela *rel,
1063			 const Elf_Internal_Rela *relend,
1064			 struct elf_link_hash_entry *h,
1065			 unsigned long r_symndx,
1066			 bfd_boolean from_relocate_section)
1067{
1068  unsigned int from_type = *r_type;
1069  unsigned int to_type = from_type;
1070  bfd_boolean check = TRUE;
1071
1072  /* Skip TLS transition for functions.  */
1073  if (h != NULL
1074      && (h->type == STT_FUNC
1075	  || h->type == STT_GNU_IFUNC))
1076    return TRUE;
1077
1078  switch (from_type)
1079    {
1080    case R_386_TLS_GD:
1081    case R_386_TLS_GOTDESC:
1082    case R_386_TLS_DESC_CALL:
1083    case R_386_TLS_IE_32:
1084    case R_386_TLS_IE:
1085    case R_386_TLS_GOTIE:
1086      if (bfd_link_executable (info))
1087	{
1088	  if (h == NULL)
1089	    to_type = R_386_TLS_LE_32;
1090	  else if (from_type != R_386_TLS_IE
1091		   && from_type != R_386_TLS_GOTIE)
1092	    to_type = R_386_TLS_IE_32;
1093	}
1094
1095      /* When we are called from elf_i386_relocate_section, there may
1096	 be additional transitions based on TLS_TYPE.  */
1097      if (from_relocate_section)
1098	{
1099	  unsigned int new_to_type = to_type;
1100
1101	  if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
1102	    new_to_type = R_386_TLS_LE_32;
1103
1104	  if (to_type == R_386_TLS_GD
1105	      || to_type == R_386_TLS_GOTDESC
1106	      || to_type == R_386_TLS_DESC_CALL)
1107	    {
1108	      if (tls_type == GOT_TLS_IE_POS)
1109		new_to_type = R_386_TLS_GOTIE;
1110	      else if (tls_type & GOT_TLS_IE)
1111		new_to_type = R_386_TLS_IE_32;
1112	    }
1113
1114	  /* We checked the transition before when we were called from
1115	     elf_i386_check_relocs.  We only want to check the new
1116	     transition which hasn't been checked before.  */
1117	  check = new_to_type != to_type && from_type == to_type;
1118	  to_type = new_to_type;
1119	}
1120
1121      break;
1122
1123    case R_386_TLS_LDM:
1124      if (bfd_link_executable (info))
1125	to_type = R_386_TLS_LE_32;
1126      break;
1127
1128    default:
1129      return TRUE;
1130    }
1131
1132  /* Return TRUE if there is no transition.  */
1133  if (from_type == to_type)
1134    return TRUE;
1135
1136  /* Check if the transition can be performed.  */
1137  if (check
1138      && ! elf_i386_check_tls_transition (sec, contents,
1139					  symtab_hdr, sym_hashes,
1140					  from_type, rel, relend))
1141    {
1142      reloc_howto_type *from, *to;
1143      const char *name;
1144
1145      from = elf_i386_rtype_to_howto (from_type);
1146      to = elf_i386_rtype_to_howto (to_type);
1147
1148      if (h)
1149	name = h->root.root.string;
1150      else
1151	{
1152	  struct elf_x86_link_hash_table *htab;
1153
1154	  htab = elf_x86_hash_table (info, I386_ELF_DATA);
1155	  if (htab == NULL)
1156	    name = "*unknown*";
1157	  else
1158	    {
1159	      Elf_Internal_Sym *isym;
1160
1161	      isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1162					    abfd, r_symndx);
1163	      name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1164	    }
1165	}
1166
1167      _bfd_error_handler
1168	/* xgettext:c-format */
1169	(_("%pB: TLS transition from %s to %s against `%s'"
1170	   " at %#" PRIx64 " in section `%pA' failed"),
1171	 abfd, from->name, to->name, name,
1172	 (uint64_t) rel->r_offset, sec);
1173      bfd_set_error (bfd_error_bad_value);
1174      return FALSE;
1175    }
1176
1177  *r_type = to_type;
1178  return TRUE;
1179}
1180
1181/* With the local symbol, foo, we convert
1182   mov foo@GOT[(%reg1)], %reg2
1183   to
1184   lea foo[@GOTOFF(%reg1)], %reg2
1185   and convert
1186   call/jmp *foo@GOT[(%reg)]
1187   to
1188   nop call foo/jmp foo nop
1189   When PIC is false, convert
1190   test %reg1, foo@GOT[(%reg2)]
1191   to
1192   test $foo, %reg1
1193   and convert
1194   binop foo@GOT[(%reg1)], %reg2
1195   to
1196   binop $foo, %reg2
1197   where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1198   instructions.  */
1199
1200static
1201bfd_boolean
1202elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1203			     bfd_byte *contents,
1204			     unsigned int *r_type_p,
1205			     Elf_Internal_Rela *irel,
1206			     struct elf_link_hash_entry *h,
1207			     bfd_boolean *converted,
1208			     struct bfd_link_info *link_info)
1209{
1210  struct elf_x86_link_hash_table *htab;
1211  unsigned int opcode;
1212  unsigned int modrm;
1213  bfd_boolean baseless;
1214  Elf_Internal_Sym *isym;
1215  unsigned int addend;
1216  unsigned int nop;
1217  bfd_vma nop_offset;
1218  bfd_boolean is_pic;
1219  bfd_boolean to_reloc_32;
1220  bfd_boolean abs_symbol;
1221  unsigned int r_type;
1222  unsigned int r_symndx;
1223  bfd_vma roff = irel->r_offset;
1224  bfd_boolean local_ref;
1225  struct elf_x86_link_hash_entry *eh;
1226
1227  if (roff < 2)
1228    return TRUE;
1229
1230  /* Addend for R_386_GOT32X relocations must be 0.  */
1231  addend = bfd_get_32 (abfd, contents + roff);
1232  if (addend != 0)
1233    return TRUE;
1234
1235  htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
1236  is_pic = bfd_link_pic (link_info);
1237
1238  r_type = *r_type_p;
1239  r_symndx = ELF32_R_SYM (irel->r_info);
1240
1241  modrm = bfd_get_8 (abfd, contents + roff - 1);
1242  baseless = (modrm & 0xc7) == 0x5;
1243
1244  if (h)
1245    {
1246      /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P.  */
1247      local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
1248      isym = NULL;
1249      abs_symbol = ABS_SYMBOL_P (h);
1250    }
1251  else
1252    {
1253      local_ref = TRUE;
1254      isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, abfd,
1255				    r_symndx);
1256      abs_symbol = isym->st_shndx == SHN_ABS;
1257    }
1258
1259  if (baseless && is_pic)
1260    {
1261      /* For PIC, disallow R_386_GOT32X without a base register
1262	 since we don't know what the GOT base is.  */
1263      const char *name;
1264
1265      if (h == NULL)
1266	name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1267      else
1268	name = h->root.root.string;
1269
1270      _bfd_error_handler
1271	/* xgettext:c-format */
1272	(_("%pB: direct GOT relocation R_386_GOT32X against `%s' without base"
1273	   " register can not be used when making a shared object"),
1274	 abfd, name);
1275      return FALSE;
1276    }
1277
1278  opcode = bfd_get_8 (abfd, contents + roff - 2);
1279
1280  /* Convert to R_386_32 if PIC is false or there is no base
1281     register.  */
1282  to_reloc_32 = !is_pic || baseless;
1283
1284  eh = elf_x86_hash_entry (h);
1285
1286  /* Try to convert R_386_GOT32X.  Get the symbol referred to by the
1287     reloc.  */
1288  if (h == NULL)
1289    {
1290      if (opcode == 0x0ff)
1291	/* Convert "call/jmp *foo@GOT[(%reg)]".  */
1292	goto convert_branch;
1293      else
1294	/* Convert "mov foo@GOT[(%reg1)], %reg2",
1295	   "test %reg1, foo@GOT(%reg2)" and
1296	   "binop foo@GOT[(%reg1)], %reg2". */
1297	goto convert_load;
1298    }
1299
1300  /* Undefined weak symbol is only bound locally in executable
1301     and its reference is resolved as 0.  */
1302  if (h->root.type == bfd_link_hash_undefweak
1303      && !eh->linker_def
1304      && local_ref)
1305    {
1306      if (opcode == 0xff)
1307	{
1308	  /* No direct branch to 0 for PIC.  */
1309	  if (is_pic)
1310	    return TRUE;
1311	  else
1312	    goto convert_branch;
1313	}
1314      else
1315	{
1316	  /* We can convert load of address 0 to R_386_32.  */
1317	  to_reloc_32 = TRUE;
1318	  goto convert_load;
1319	}
1320    }
1321
1322  if (opcode == 0xff)
1323    {
1324      /* We have "call/jmp *foo@GOT[(%reg)]".  */
1325      if ((h->root.type == bfd_link_hash_defined
1326	   || h->root.type == bfd_link_hash_defweak)
1327	  && local_ref)
1328	{
1329	  /* The function is locally defined.   */
1330	convert_branch:
1331	  /* Convert R_386_GOT32X to R_386_PC32.  */
1332	  if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1333	    {
1334	      /* Convert to "nop call foo".  ADDR_PREFIX_OPCODE
1335		 is a nop prefix.  */
1336	      modrm = 0xe8;
1337	      /* To support TLS optimization, always use addr32 prefix
1338		 for "call *___tls_get_addr@GOT(%reg)".  */
1339	      if (eh && eh->tls_get_addr)
1340		{
1341		  nop = 0x67;
1342		  nop_offset = irel->r_offset - 2;
1343		}
1344	      else
1345		{
1346		  nop = htab->params->call_nop_byte;
1347		  if (htab->params->call_nop_as_suffix)
1348		    {
1349		      nop_offset = roff + 3;
1350		      irel->r_offset -= 1;
1351		    }
1352		  else
1353		    nop_offset = roff - 2;
1354		}
1355	    }
1356	  else
1357	    {
1358	      /* Convert to "jmp foo nop".  */
1359	      modrm = 0xe9;
1360	      nop = NOP_OPCODE;
1361	      nop_offset = roff + 3;
1362	      irel->r_offset -= 1;
1363	    }
1364
1365	  bfd_put_8 (abfd, nop, contents + nop_offset);
1366	  bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1367	  /* When converting to PC-relative relocation, we
1368	     need to adjust addend by -4.  */
1369	  bfd_put_32 (abfd, -4, contents + irel->r_offset);
1370	  irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1371	  *r_type_p = R_386_PC32;
1372	  *converted = TRUE;
1373	}
1374    }
1375  else
1376    {
1377      /* We have "mov foo@GOT[(%re1g)], %reg2",
1378	 "test %reg1, foo@GOT(%reg2)" and
1379	 "binop foo@GOT[(%reg1)], %reg2".
1380
1381	 Avoid optimizing _DYNAMIC since ld.so may use its
1382	 link-time address.  */
1383      if (h == htab->elf.hdynamic)
1384	return TRUE;
1385
1386      /* def_regular is set by an assignment in a linker script in
1387	 bfd_elf_record_link_assignment.  start_stop is set on
1388	 __start_SECNAME/__stop_SECNAME which mark section SECNAME.  */
1389      if (h->start_stop
1390	  || eh->linker_def
1391	  || ((h->def_regular
1392	       || h->root.type == bfd_link_hash_defined
1393	       || h->root.type == bfd_link_hash_defweak)
1394	      && local_ref))
1395	{
1396	convert_load:
1397	  if (opcode == 0x8b)
1398	    {
1399	      if (abs_symbol && local_ref)
1400		to_reloc_32 = TRUE;
1401
1402	      if (to_reloc_32)
1403		{
1404		  /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1405		     "mov $foo, %reg2" with R_386_32.  */
1406		  r_type = R_386_32;
1407		  modrm = 0xc0 | (modrm & 0x38) >> 3;
1408		  bfd_put_8 (abfd, modrm, contents + roff - 1);
1409		  opcode = 0xc7;
1410		}
1411	      else
1412		{
1413		  /* Convert "mov foo@GOT(%reg1), %reg2" to
1414		     "lea foo@GOTOFF(%reg1), %reg2".  */
1415		  r_type = R_386_GOTOFF;
1416		  opcode = 0x8d;
1417		}
1418	    }
1419	  else
1420	    {
1421	      /* Only R_386_32 is supported.  */
1422	      if (!to_reloc_32)
1423		return TRUE;
1424
1425	      if (opcode == 0x85)
1426		{
1427		  /* Convert "test %reg1, foo@GOT(%reg2)" to
1428		     "test $foo, %reg1".  */
1429		  modrm = 0xc0 | (modrm & 0x38) >> 3;
1430		  opcode = 0xf7;
1431		}
1432	      else
1433		{
1434		  /* Convert "binop foo@GOT(%reg1), %reg2" to
1435		     "binop $foo, %reg2".  */
1436		  modrm = (0xc0
1437			   | (modrm & 0x38) >> 3
1438			   | (opcode & 0x3c));
1439		  opcode = 0x81;
1440		}
1441	      bfd_put_8 (abfd, modrm, contents + roff - 1);
1442	      r_type = R_386_32;
1443	    }
1444
1445	  bfd_put_8 (abfd, opcode, contents + roff - 2);
1446	  irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1447	  *r_type_p = r_type;
1448	  *converted = TRUE;
1449	}
1450    }
1451
1452  return TRUE;
1453}
1454
1455/* Rename some of the generic section flags to better document how they
1456   are used here.  */
1457#define check_relocs_failed	sec_flg0
1458
1459/* Look through the relocs for a section during the first phase, and
1460   calculate needed space in the global offset table, procedure linkage
1461   table, and dynamic reloc sections.  */
1462
1463static bfd_boolean
1464elf_i386_check_relocs (bfd *abfd,
1465		       struct bfd_link_info *info,
1466		       asection *sec,
1467		       const Elf_Internal_Rela *relocs)
1468{
1469  struct elf_x86_link_hash_table *htab;
1470  Elf_Internal_Shdr *symtab_hdr;
1471  struct elf_link_hash_entry **sym_hashes;
1472  const Elf_Internal_Rela *rel;
1473  const Elf_Internal_Rela *rel_end;
1474  asection *sreloc;
1475  bfd_byte *contents;
1476  bfd_boolean converted;
1477
1478  if (bfd_link_relocatable (info))
1479    return TRUE;
1480
1481  htab = elf_x86_hash_table (info, I386_ELF_DATA);
1482  if (htab == NULL)
1483    {
1484      sec->check_relocs_failed = 1;
1485      return FALSE;
1486    }
1487
1488  BFD_ASSERT (is_x86_elf (abfd, htab));
1489
1490  /* Get the section contents.  */
1491  if (elf_section_data (sec)->this_hdr.contents != NULL)
1492    contents = elf_section_data (sec)->this_hdr.contents;
1493  else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1494    {
1495      sec->check_relocs_failed = 1;
1496      return FALSE;
1497    }
1498
1499  symtab_hdr = &elf_symtab_hdr (abfd);
1500  sym_hashes = elf_sym_hashes (abfd);
1501
1502  converted = FALSE;
1503
1504  sreloc = NULL;
1505
1506  rel_end = relocs + sec->reloc_count;
1507  for (rel = relocs; rel < rel_end; rel++)
1508    {
1509      unsigned int r_type;
1510      unsigned int r_symndx;
1511      struct elf_link_hash_entry *h;
1512      struct elf_x86_link_hash_entry *eh;
1513      Elf_Internal_Sym *isym;
1514      const char *name;
1515      bfd_boolean size_reloc;
1516      bfd_boolean no_dynreloc;
1517
1518      r_symndx = ELF32_R_SYM (rel->r_info);
1519      r_type = ELF32_R_TYPE (rel->r_info);
1520
1521      if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1522	{
1523	  /* xgettext:c-format */
1524	  _bfd_error_handler (_("%pB: bad symbol index: %d"),
1525			      abfd, r_symndx);
1526	  goto error_return;
1527	}
1528
1529      if (r_symndx < symtab_hdr->sh_info)
1530	{
1531	  /* A local symbol.  */
1532	  isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1533					abfd, r_symndx);
1534	  if (isym == NULL)
1535	    goto error_return;
1536
1537	  /* Check relocation against local STT_GNU_IFUNC symbol.  */
1538	  if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1539	    {
1540	      h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel, TRUE);
1541	      if (h == NULL)
1542		goto error_return;
1543
1544	      /* Fake a STT_GNU_IFUNC symbol.  */
1545	      h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1546						      isym, NULL);
1547	      h->type = STT_GNU_IFUNC;
1548	      h->def_regular = 1;
1549	      h->ref_regular = 1;
1550	      h->forced_local = 1;
1551	      h->root.type = bfd_link_hash_defined;
1552	    }
1553	  else
1554	    h = NULL;
1555	}
1556      else
1557	{
1558	  isym = NULL;
1559	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1560	  while (h->root.type == bfd_link_hash_indirect
1561		 || h->root.type == bfd_link_hash_warning)
1562	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1563	}
1564
1565      eh = (struct elf_x86_link_hash_entry *) h;
1566      if (h != NULL)
1567	{
1568	  if (r_type == R_386_GOTOFF)
1569	    eh->gotoff_ref = 1;
1570
1571	  /* It is referenced by a non-shared object. */
1572	  h->ref_regular = 1;
1573	}
1574
1575      if (r_type == R_386_GOT32X
1576	  && (h == NULL || h->type != STT_GNU_IFUNC))
1577	{
1578	  Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
1579	  if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
1580					    &r_type, irel, h,
1581					    &converted, info))
1582	    goto error_return;
1583	}
1584
1585      if (!_bfd_elf_x86_valid_reloc_p (sec, info, htab, rel, h, isym,
1586				       symtab_hdr, &no_dynreloc))
1587	return FALSE;
1588
1589      if (! elf_i386_tls_transition (info, abfd, sec, contents,
1590				     symtab_hdr, sym_hashes,
1591				     &r_type, GOT_UNKNOWN,
1592				     rel, rel_end, h, r_symndx, FALSE))
1593	goto error_return;
1594
1595      /* Check if _GLOBAL_OFFSET_TABLE_ is referenced.  */
1596      if (h == htab->elf.hgot)
1597	htab->got_referenced = TRUE;
1598
1599      switch (r_type)
1600	{
1601	case R_386_TLS_LDM:
1602	  htab->tls_ld_or_ldm_got.refcount = 1;
1603	  goto create_got;
1604
1605	case R_386_PLT32:
1606	  /* This symbol requires a procedure linkage table entry.  We
1607	     actually build the entry in adjust_dynamic_symbol,
1608	     because this might be a case of linking PIC code which is
1609	     never referenced by a dynamic object, in which case we
1610	     don't need to generate a procedure linkage table entry
1611	     after all.  */
1612
1613	  /* If this is a local symbol, we resolve it directly without
1614	     creating a procedure linkage table entry.  */
1615	  if (h == NULL)
1616	    continue;
1617
1618	  eh->zero_undefweak &= 0x2;
1619	  h->needs_plt = 1;
1620	  h->plt.refcount = 1;
1621	  break;
1622
1623	case R_386_SIZE32:
1624	  size_reloc = TRUE;
1625	  goto do_size;
1626
1627	case R_386_TLS_IE_32:
1628	case R_386_TLS_IE:
1629	case R_386_TLS_GOTIE:
1630	  if (!bfd_link_executable (info))
1631	    info->flags |= DF_STATIC_TLS;
1632	  /* Fall through */
1633
1634	case R_386_GOT32:
1635	case R_386_GOT32X:
1636	case R_386_TLS_GD:
1637	case R_386_TLS_GOTDESC:
1638	case R_386_TLS_DESC_CALL:
1639	  /* This symbol requires a global offset table entry.  */
1640	  {
1641	    int tls_type, old_tls_type;
1642
1643	    switch (r_type)
1644	      {
1645	      default:
1646	      case R_386_GOT32:
1647	      case R_386_GOT32X:
1648		tls_type = GOT_NORMAL;
1649		break;
1650	      case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1651	      case R_386_TLS_GOTDESC:
1652	      case R_386_TLS_DESC_CALL:
1653		tls_type = GOT_TLS_GDESC; break;
1654	      case R_386_TLS_IE_32:
1655		if (ELF32_R_TYPE (rel->r_info) == r_type)
1656		  tls_type = GOT_TLS_IE_NEG;
1657		else
1658		  /* If this is a GD->IE transition, we may use either of
1659		     R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
1660		  tls_type = GOT_TLS_IE;
1661		break;
1662	      case R_386_TLS_IE:
1663	      case R_386_TLS_GOTIE:
1664		tls_type = GOT_TLS_IE_POS; break;
1665	      }
1666
1667	    if (h != NULL)
1668	      {
1669		h->got.refcount = 1;
1670		old_tls_type = elf_x86_hash_entry (h)->tls_type;
1671	      }
1672	    else
1673	      {
1674		bfd_signed_vma *local_got_refcounts;
1675
1676		/* This is a global offset table entry for a local symbol.  */
1677		local_got_refcounts = elf_local_got_refcounts (abfd);
1678		if (local_got_refcounts == NULL)
1679		  {
1680		    bfd_size_type size;
1681
1682		    size = symtab_hdr->sh_info;
1683		    size *= (sizeof (bfd_signed_vma)
1684			     + sizeof (bfd_vma) + sizeof(char));
1685		    local_got_refcounts = (bfd_signed_vma *)
1686			bfd_zalloc (abfd, size);
1687		    if (local_got_refcounts == NULL)
1688		      goto error_return;
1689		    elf_local_got_refcounts (abfd) = local_got_refcounts;
1690		    elf_x86_local_tlsdesc_gotent (abfd)
1691		      = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1692		    elf_x86_local_got_tls_type (abfd)
1693		      = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1694		  }
1695		local_got_refcounts[r_symndx] = 1;
1696		old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx];
1697	      }
1698
1699	    if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1700	      tls_type |= old_tls_type;
1701	    /* If a TLS symbol is accessed using IE at least once,
1702	       there is no point to use dynamic model for it.  */
1703	    else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1704		     && (! GOT_TLS_GD_ANY_P (old_tls_type)
1705			 || (tls_type & GOT_TLS_IE) == 0))
1706	      {
1707		if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1708		  tls_type = old_tls_type;
1709		else if (GOT_TLS_GD_ANY_P (old_tls_type)
1710			 && GOT_TLS_GD_ANY_P (tls_type))
1711		  tls_type |= old_tls_type;
1712		else
1713		  {
1714		    if (h)
1715		      name = h->root.root.string;
1716		    else
1717		      name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1718					     NULL);
1719		    _bfd_error_handler
1720		      /* xgettext:c-format */
1721		      (_("%pB: `%s' accessed both as normal and "
1722			 "thread local symbol"),
1723		       abfd, name);
1724		    bfd_set_error (bfd_error_bad_value);
1725		    goto error_return;
1726		  }
1727	      }
1728
1729	    if (old_tls_type != tls_type)
1730	      {
1731		if (h != NULL)
1732		  elf_x86_hash_entry (h)->tls_type = tls_type;
1733		else
1734		  elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
1735	      }
1736	  }
1737	  /* Fall through */
1738
1739	case R_386_GOTOFF:
1740	case R_386_GOTPC:
1741	create_got:
1742	  if (r_type != R_386_TLS_IE)
1743	    {
1744	      if (eh != NULL)
1745		{
1746		  eh->zero_undefweak &= 0x2;
1747
1748		  /* Need GOT to resolve undefined weak symbol to 0.  */
1749		  if (r_type == R_386_GOTOFF
1750		      && h->root.type == bfd_link_hash_undefweak
1751		      && bfd_link_executable (info))
1752		    htab->got_referenced = TRUE;
1753		}
1754	      break;
1755	    }
1756	  /* Fall through */
1757
1758	case R_386_TLS_LE_32:
1759	case R_386_TLS_LE:
1760	  if (eh != NULL)
1761	    eh->zero_undefweak &= 0x2;
1762	  if (bfd_link_executable (info))
1763	    break;
1764	  info->flags |= DF_STATIC_TLS;
1765	  goto do_relocation;
1766
1767	case R_386_32:
1768	case R_386_PC32:
1769	  if (eh != NULL && (sec->flags & SEC_CODE) != 0)
1770	    eh->zero_undefweak |= 0x2;
1771	do_relocation:
1772	  /* We are called after all symbols have been resolved.  Only
1773	     relocation against STT_GNU_IFUNC symbol must go through
1774	     PLT.  */
1775	  if (h != NULL
1776	      && (bfd_link_executable (info)
1777		  || h->type == STT_GNU_IFUNC))
1778	    {
1779	      bfd_boolean func_pointer_ref = FALSE;
1780
1781	      if (r_type == R_386_PC32)
1782		{
1783		  /* Since something like ".long foo - ." may be used
1784		     as pointer, make sure that PLT is used if foo is
1785		     a function defined in a shared library.  */
1786		  if ((sec->flags & SEC_CODE) == 0)
1787		    h->pointer_equality_needed = 1;
1788		  else if (h->type == STT_GNU_IFUNC
1789			   && bfd_link_pic (info))
1790		    {
1791		      _bfd_error_handler
1792			/* xgettext:c-format */
1793			(_("%pB: unsupported non-PIC call to IFUNC `%s'"),
1794			 abfd, h->root.root.string);
1795		      bfd_set_error (bfd_error_bad_value);
1796		      goto error_return;
1797		    }
1798		}
1799	      else
1800		{
1801		  h->pointer_equality_needed = 1;
1802		  /* R_386_32 can be resolved at run-time.  */
1803		  if (r_type == R_386_32
1804		      && (sec->flags & SEC_READONLY) == 0)
1805		    func_pointer_ref = TRUE;
1806		}
1807
1808	      if (!func_pointer_ref)
1809		{
1810		  /* If this reloc is in a read-only section, we might
1811		     need a copy reloc.  We can't check reliably at this
1812		     stage whether the section is read-only, as input
1813		     sections have not yet been mapped to output sections.
1814		     Tentatively set the flag for now, and correct in
1815		     adjust_dynamic_symbol.  */
1816		  h->non_got_ref = 1;
1817
1818		  /* We may need a .plt entry if the symbol is a function
1819		     defined in a shared lib or is a function referenced
1820		     from the code or read-only section.  */
1821		  if (!h->def_regular
1822		      || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
1823		    h->plt.refcount = 1;
1824		}
1825	    }
1826
1827	  size_reloc = FALSE;
1828	do_size:
1829	  if (!no_dynreloc
1830	      && NEED_DYNAMIC_RELOCATION_P (info, FALSE, h, sec, r_type,
1831					    R_386_32))
1832	    {
1833	      struct elf_dyn_relocs *p;
1834	      struct elf_dyn_relocs **head;
1835
1836	      /* We must copy these reloc types into the output file.
1837		 Create a reloc section in dynobj and make room for
1838		 this reloc.  */
1839	      if (sreloc == NULL)
1840		{
1841		  sreloc = _bfd_elf_make_dynamic_reloc_section
1842		    (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1843
1844		  if (sreloc == NULL)
1845		    goto error_return;
1846		}
1847
1848	      /* If this is a global symbol, we count the number of
1849		 relocations we need for this symbol.  */
1850	      if (h != NULL)
1851		{
1852		  head = &h->dyn_relocs;
1853		}
1854	      else
1855		{
1856		  /* Track dynamic relocs needed for local syms too.
1857		     We really need local syms available to do this
1858		     easily.  Oh well.  */
1859		  void **vpp;
1860		  asection *s;
1861
1862		  isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1863						abfd, r_symndx);
1864		  if (isym == NULL)
1865		    goto error_return;
1866
1867		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1868		  if (s == NULL)
1869		    s = sec;
1870
1871		  vpp = &elf_section_data (s)->local_dynrel;
1872		  head = (struct elf_dyn_relocs **)vpp;
1873		}
1874
1875	      p = *head;
1876	      if (p == NULL || p->sec != sec)
1877		{
1878		  size_t amt = sizeof *p;
1879		  p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1880							   amt);
1881		  if (p == NULL)
1882		    goto error_return;
1883		  p->next = *head;
1884		  *head = p;
1885		  p->sec = sec;
1886		  p->count = 0;
1887		  p->pc_count = 0;
1888		}
1889
1890	      p->count += 1;
1891	      /* Count size relocation as PC-relative relocation.  */
1892	      if (r_type == R_386_PC32 || size_reloc)
1893		p->pc_count += 1;
1894	    }
1895	  break;
1896
1897	  /* This relocation describes the C++ object vtable hierarchy.
1898	     Reconstruct it for later use during GC.  */
1899	case R_386_GNU_VTINHERIT:
1900	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1901	    goto error_return;
1902	  break;
1903
1904	  /* This relocation describes which C++ vtable entries are actually
1905	     used.  Record for later use during GC.  */
1906	case R_386_GNU_VTENTRY:
1907	  if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1908	    goto error_return;
1909	  break;
1910
1911	default:
1912	  break;
1913	}
1914    }
1915
1916  if (elf_section_data (sec)->this_hdr.contents != contents)
1917    {
1918      if (!converted && !info->keep_memory)
1919	free (contents);
1920      else
1921	{
1922	  /* Cache the section contents for elf_link_input_bfd if any
1923	     load is converted or --no-keep-memory isn't used.  */
1924	  elf_section_data (sec)->this_hdr.contents = contents;
1925	}
1926    }
1927
1928  /* Cache relocations if any load is converted.  */
1929  if (elf_section_data (sec)->relocs != relocs && converted)
1930    elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
1931
1932  return TRUE;
1933
1934 error_return:
1935  if (elf_section_data (sec)->this_hdr.contents != contents)
1936    free (contents);
1937  sec->check_relocs_failed = 1;
1938  return FALSE;
1939}
1940
1941/* Set the correct type for an x86 ELF section.  We do this by the
1942   section name, which is a hack, but ought to work.  */
1943
1944static bfd_boolean
1945elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1946			Elf_Internal_Shdr *hdr,
1947			asection *sec)
1948{
1949  const char *name;
1950
1951  name = bfd_section_name (sec);
1952
1953  /* This is an ugly, but unfortunately necessary hack that is
1954     needed when producing EFI binaries on x86. It tells
1955     elf.c:elf_fake_sections() not to consider ".reloc" as a section
1956     containing ELF relocation info.  We need this hack in order to
1957     be able to generate ELF binaries that can be translated into
1958     EFI applications (which are essentially COFF objects).  Those
1959     files contain a COFF ".reloc" section inside an ELFNN object,
1960     which would normally cause BFD to segfault because it would
1961     attempt to interpret this section as containing relocation
1962     entries for section "oc".  With this hack enabled, ".reloc"
1963     will be treated as a normal data section, which will avoid the
1964     segfault.  However, you won't be able to create an ELFNN binary
1965     with a section named "oc" that needs relocations, but that's
1966     the kind of ugly side-effects you get when detecting section
1967     types based on their names...  In practice, this limitation is
1968     unlikely to bite.  */
1969  if (strcmp (name, ".reloc") == 0)
1970    hdr->sh_type = SHT_PROGBITS;
1971
1972  return TRUE;
1973}
1974
1975/* Return the relocation value for @tpoff relocation
1976   if STT_TLS virtual address is ADDRESS.  */
1977
1978static bfd_vma
1979elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
1980{
1981  struct elf_link_hash_table *htab = elf_hash_table (info);
1982  const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
1983  bfd_vma static_tls_size;
1984
1985  /* If tls_sec is NULL, we should have signalled an error already.  */
1986  if (htab->tls_sec == NULL)
1987    return 0;
1988
1989  /* Consider special static TLS alignment requirements.  */
1990  static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
1991  return static_tls_size + htab->tls_sec->vma - address;
1992}
1993
1994/* Relocate an i386 ELF section.  */
1995
1996static bfd_boolean
1997elf_i386_relocate_section (bfd *output_bfd,
1998			   struct bfd_link_info *info,
1999			   bfd *input_bfd,
2000			   asection *input_section,
2001			   bfd_byte *contents,
2002			   Elf_Internal_Rela *relocs,
2003			   Elf_Internal_Sym *local_syms,
2004			   asection **local_sections)
2005{
2006  struct elf_x86_link_hash_table *htab;
2007  Elf_Internal_Shdr *symtab_hdr;
2008  struct elf_link_hash_entry **sym_hashes;
2009  bfd_vma *local_got_offsets;
2010  bfd_vma *local_tlsdesc_gotents;
2011  Elf_Internal_Rela *rel;
2012  Elf_Internal_Rela *wrel;
2013  Elf_Internal_Rela *relend;
2014  bfd_boolean is_vxworks_tls;
2015  unsigned plt_entry_size;
2016
2017  /* Skip if check_relocs failed.  */
2018  if (input_section->check_relocs_failed)
2019    return FALSE;
2020
2021  htab = elf_x86_hash_table (info, I386_ELF_DATA);
2022  if (htab == NULL)
2023    return FALSE;
2024
2025  if (!is_x86_elf (input_bfd, htab))
2026    {
2027      bfd_set_error (bfd_error_wrong_format);
2028      return FALSE;
2029    }
2030
2031  symtab_hdr = &elf_symtab_hdr (input_bfd);
2032  sym_hashes = elf_sym_hashes (input_bfd);
2033  local_got_offsets = elf_local_got_offsets (input_bfd);
2034  local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2035  /* We have to handle relocations in vxworks .tls_vars sections
2036     specially, because the dynamic loader is 'weird'.  */
2037  is_vxworks_tls = (htab->elf.target_os == is_vxworks
2038		    && bfd_link_pic (info)
2039		    && !strcmp (input_section->output_section->name,
2040				".tls_vars"));
2041
2042  _bfd_x86_elf_set_tls_module_base (info);
2043
2044  plt_entry_size = htab->plt.plt_entry_size;
2045
2046  rel = wrel = relocs;
2047  relend = relocs + input_section->reloc_count;
2048  for (; rel < relend; wrel++, rel++)
2049    {
2050      unsigned int r_type, r_type_tls;
2051      reloc_howto_type *howto;
2052      unsigned long r_symndx;
2053      struct elf_link_hash_entry *h;
2054      struct elf_x86_link_hash_entry *eh;
2055      Elf_Internal_Sym *sym;
2056      asection *sec;
2057      bfd_vma off, offplt, plt_offset;
2058      bfd_vma relocation;
2059      bfd_boolean unresolved_reloc;
2060      bfd_reloc_status_type r;
2061      unsigned int indx;
2062      int tls_type;
2063      bfd_vma st_size;
2064      asection *resolved_plt;
2065      bfd_boolean resolved_to_zero;
2066      bfd_boolean relative_reloc;
2067
2068      r_type = ELF32_R_TYPE (rel->r_info);
2069      if (r_type == R_386_GNU_VTINHERIT
2070	  || r_type == R_386_GNU_VTENTRY)
2071	{
2072	  if (wrel != rel)
2073	    *wrel = *rel;
2074	  continue;
2075	}
2076
2077      howto = elf_i386_rtype_to_howto (r_type);
2078      if (howto == NULL)
2079	return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2080
2081      r_symndx = ELF32_R_SYM (rel->r_info);
2082      h = NULL;
2083      sym = NULL;
2084      sec = NULL;
2085      unresolved_reloc = FALSE;
2086      if (r_symndx < symtab_hdr->sh_info)
2087	{
2088	  sym = local_syms + r_symndx;
2089	  sec = local_sections[r_symndx];
2090	  relocation = (sec->output_section->vma
2091			+ sec->output_offset
2092			+ sym->st_value);
2093	  st_size = sym->st_size;
2094
2095	  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2096	      && ((sec->flags & SEC_MERGE) != 0
2097		  || (bfd_link_relocatable (info)
2098		      && sec->output_offset != 0)))
2099	    {
2100	      bfd_vma addend;
2101	      bfd_byte *where = contents + rel->r_offset;
2102
2103	      switch (howto->size)
2104		{
2105		case 0:
2106		  addend = bfd_get_8 (input_bfd, where);
2107		  if (howto->pc_relative)
2108		    {
2109		      addend = (addend ^ 0x80) - 0x80;
2110		      addend += 1;
2111		    }
2112		  break;
2113		case 1:
2114		  addend = bfd_get_16 (input_bfd, where);
2115		  if (howto->pc_relative)
2116		    {
2117		      addend = (addend ^ 0x8000) - 0x8000;
2118		      addend += 2;
2119		    }
2120		  break;
2121		case 2:
2122		  addend = bfd_get_32 (input_bfd, where);
2123		  if (howto->pc_relative)
2124		    {
2125		      addend = (addend ^ 0x80000000) - 0x80000000;
2126		      addend += 4;
2127		    }
2128		  break;
2129		default:
2130		  abort ();
2131		}
2132
2133	      if (bfd_link_relocatable (info))
2134		addend += sec->output_offset;
2135	      else
2136		{
2137		  asection *msec = sec;
2138		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2139						   addend);
2140		  addend -= relocation;
2141		  addend += msec->output_section->vma + msec->output_offset;
2142		}
2143
2144	      switch (howto->size)
2145		{
2146		case 0:
2147		  /* FIXME: overflow checks.  */
2148		  if (howto->pc_relative)
2149		    addend -= 1;
2150		  bfd_put_8 (input_bfd, addend, where);
2151		  break;
2152		case 1:
2153		  if (howto->pc_relative)
2154		    addend -= 2;
2155		  bfd_put_16 (input_bfd, addend, where);
2156		  break;
2157		case 2:
2158		  if (howto->pc_relative)
2159		    addend -= 4;
2160		  bfd_put_32 (input_bfd, addend, where);
2161		  break;
2162		}
2163	    }
2164	  else if (!bfd_link_relocatable (info)
2165		   && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2166	    {
2167	      /* Relocate against local STT_GNU_IFUNC symbol.  */
2168	      h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd, rel,
2169						   FALSE);
2170	      if (h == NULL)
2171		abort ();
2172
2173	      /* Set STT_GNU_IFUNC symbol value.  */
2174	      h->root.u.def.value = sym->st_value;
2175	      h->root.u.def.section = sec;
2176	    }
2177	}
2178      else
2179	{
2180	  bfd_boolean warned ATTRIBUTE_UNUSED;
2181	  bfd_boolean ignored ATTRIBUTE_UNUSED;
2182
2183	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2184				   r_symndx, symtab_hdr, sym_hashes,
2185				   h, sec, relocation,
2186				   unresolved_reloc, warned, ignored);
2187	  st_size = h->size;
2188	}
2189
2190      if (sec != NULL && discarded_section (sec))
2191	{
2192	  _bfd_clear_contents (howto, input_bfd, input_section,
2193			       contents, rel->r_offset);
2194	  wrel->r_offset = rel->r_offset;
2195	  wrel->r_info = 0;
2196	  wrel->r_addend = 0;
2197
2198	  /* For ld -r, remove relocations in debug sections against
2199	     sections defined in discarded sections.  Not done for
2200	     eh_frame editing code expects to be present.  */
2201	   if (bfd_link_relocatable (info)
2202	       && (input_section->flags & SEC_DEBUGGING))
2203	     wrel--;
2204
2205	   continue;
2206	}
2207
2208      if (bfd_link_relocatable (info))
2209	{
2210	  if (wrel != rel)
2211	    *wrel = *rel;
2212	  continue;
2213	}
2214
2215      eh = (struct elf_x86_link_hash_entry *) h;
2216
2217      /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2218	 it here if it is defined in a non-shared object.  */
2219      if (h != NULL
2220	  && h->type == STT_GNU_IFUNC
2221	  && h->def_regular)
2222	{
2223	  asection *gotplt, *base_got;
2224	  bfd_vma plt_index;
2225	  const char *name;
2226
2227	  if ((input_section->flags & SEC_ALLOC) == 0)
2228	    {
2229	      /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2230	         STT_GNU_IFUNC symbol as STT_FUNC.  */
2231	      if (elf_section_type (input_section) == SHT_NOTE)
2232		goto skip_ifunc;
2233	      /* Dynamic relocs are not propagated for SEC_DEBUGGING
2234		 sections because such sections are not SEC_ALLOC and
2235		 thus ld.so will not process them.  */
2236	      if ((input_section->flags & SEC_DEBUGGING) != 0)
2237		continue;
2238	      abort ();
2239	    }
2240
2241	  /* STT_GNU_IFUNC symbol must go through PLT.  */
2242	  if (htab->elf.splt != NULL)
2243	    {
2244	      if (htab->plt_second != NULL)
2245		{
2246		  resolved_plt = htab->plt_second;
2247		  plt_offset = eh->plt_second.offset;
2248		}
2249	      else
2250		{
2251		  resolved_plt = htab->elf.splt;
2252		  plt_offset = h->plt.offset;
2253		}
2254	      gotplt = htab->elf.sgotplt;
2255	    }
2256	  else
2257	    {
2258	      resolved_plt = htab->elf.iplt;
2259	      plt_offset = h->plt.offset;
2260	      gotplt = htab->elf.igotplt;
2261	    }
2262
2263	  switch (r_type)
2264	    {
2265	    default:
2266	      break;
2267
2268	    case R_386_GOT32:
2269	    case R_386_GOT32X:
2270	      base_got = htab->elf.sgot;
2271	      off = h->got.offset;
2272
2273	      if (base_got == NULL)
2274		abort ();
2275
2276	      if (off == (bfd_vma) -1)
2277		{
2278		  /* We can't use h->got.offset here to save state, or
2279		     even just remember the offset, as finish_dynamic_symbol
2280		     would use that as offset into .got.  */
2281
2282		  if (h->plt.offset == (bfd_vma) -1)
2283		    abort ();
2284
2285		  if (htab->elf.splt != NULL)
2286		    {
2287		      plt_index = (h->plt.offset / plt_entry_size
2288				   - htab->plt.has_plt0);
2289		      off = (plt_index + 3) * 4;
2290		      base_got = htab->elf.sgotplt;
2291		    }
2292		  else
2293		    {
2294		      plt_index = h->plt.offset / plt_entry_size;
2295		      off = plt_index * 4;
2296		      base_got = htab->elf.igotplt;
2297		    }
2298
2299		  if (h->dynindx == -1
2300		      || h->forced_local
2301		      || info->symbolic)
2302		    {
2303		      /* This references the local defitionion.  We must
2304			 initialize this entry in the global offset table.
2305			 Since the offset must always be a multiple of 8,
2306			 we use the least significant bit to record
2307			 whether we have initialized it already.
2308
2309			 When doing a dynamic link, we create a .rela.got
2310			 relocation entry to initialize the value.  This
2311			 is done in the finish_dynamic_symbol routine.	 */
2312		      if ((off & 1) != 0)
2313			off &= ~1;
2314		      else
2315			{
2316			  bfd_put_32 (output_bfd, relocation,
2317				      base_got->contents + off);
2318			  h->got.offset |= 1;
2319			}
2320		    }
2321
2322		  relocation = off;
2323		}
2324	      else
2325		relocation = (base_got->output_section->vma
2326			      + base_got->output_offset + off
2327			      - gotplt->output_section->vma
2328			      - gotplt->output_offset);
2329
2330	      if (rel->r_offset > 1
2331		  && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2332		  && *(contents + rel->r_offset - 2) != 0x8d)
2333		{
2334		  if (bfd_link_pic (info))
2335		    goto disallow_got32;
2336
2337		  /* Add the GOT base if there is no base register.  */
2338		  relocation += (gotplt->output_section->vma
2339				 + gotplt->output_offset);
2340		}
2341	      else if (htab->elf.splt == NULL)
2342		{
2343		  /* Adjust for static executables.  */
2344		  relocation += gotplt->output_offset;
2345		}
2346
2347	      goto do_relocation;
2348	    }
2349
2350	  if (h->plt.offset == (bfd_vma) -1)
2351	    {
2352	      /* Handle static pointers of STT_GNU_IFUNC symbols.  */
2353	      if (r_type == R_386_32
2354		  && (input_section->flags & SEC_CODE) == 0)
2355		goto do_ifunc_pointer;
2356	      goto bad_ifunc_reloc;
2357	    }
2358
2359	  relocation = (resolved_plt->output_section->vma
2360			+ resolved_plt->output_offset + plt_offset);
2361
2362	  switch (r_type)
2363	    {
2364	    default:
2365	    bad_ifunc_reloc:
2366	      if (h->root.root.string)
2367		name = h->root.root.string;
2368	      else
2369		name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2370					 NULL);
2371	      _bfd_error_handler
2372		/* xgettext:c-format */
2373		(_("%pB: relocation %s against STT_GNU_IFUNC "
2374		   "symbol `%s' isn't supported"), input_bfd,
2375		 howto->name, name);
2376	      bfd_set_error (bfd_error_bad_value);
2377	      return FALSE;
2378
2379	    case R_386_32:
2380	      /* Generate dynamic relcoation only when there is a
2381		 non-GOT reference in a shared object.  */
2382	      if ((bfd_link_pic (info) && h->non_got_ref)
2383		  || h->plt.offset == (bfd_vma) -1)
2384		{
2385		  Elf_Internal_Rela outrel;
2386		  asection *sreloc;
2387		  bfd_vma offset;
2388
2389		do_ifunc_pointer:
2390		  /* Need a dynamic relocation to get the real function
2391		     adddress.  */
2392		  offset = _bfd_elf_section_offset (output_bfd,
2393						    info,
2394						    input_section,
2395						    rel->r_offset);
2396		  if (offset == (bfd_vma) -1
2397		      || offset == (bfd_vma) -2)
2398		    abort ();
2399
2400		  outrel.r_offset = (input_section->output_section->vma
2401				     + input_section->output_offset
2402				     + offset);
2403
2404		  if (POINTER_LOCAL_IFUNC_P (info, h))
2405		    {
2406		      info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
2407					      h->root.root.string,
2408					      h->root.u.def.section->owner);
2409
2410		      /* This symbol is resolved locally.  */
2411		      outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
2412		      bfd_put_32 (output_bfd,
2413				  (h->root.u.def.value
2414				   + h->root.u.def.section->output_section->vma
2415				   + h->root.u.def.section->output_offset),
2416				  contents + offset);
2417		    }
2418		  else
2419		    outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2420
2421		  /* Dynamic relocations are stored in
2422		     1. .rel.ifunc section in PIC object.
2423		     2. .rel.got section in dynamic executable.
2424		     3. .rel.iplt section in static executable.  */
2425		  if (bfd_link_pic (info))
2426		    sreloc = htab->elf.irelifunc;
2427		  else if (htab->elf.splt != NULL)
2428		    sreloc = htab->elf.srelgot;
2429		  else
2430		    sreloc = htab->elf.irelplt;
2431		  elf_append_rel (output_bfd, sreloc, &outrel);
2432
2433		  /* If this reloc is against an external symbol, we
2434		     do not want to fiddle with the addend.  Otherwise,
2435		     we need to include the symbol value so that it
2436		     becomes an addend for the dynamic reloc.  For an
2437		     internal symbol, we have updated addend.  */
2438		  continue;
2439		}
2440	      /* FALLTHROUGH */
2441	    case R_386_PC32:
2442	    case R_386_PLT32:
2443	      goto do_relocation;
2444
2445	    case R_386_GOTOFF:
2446	      relocation -= (gotplt->output_section->vma
2447			     + gotplt->output_offset);
2448	      goto do_relocation;
2449	    }
2450	}
2451
2452    skip_ifunc:
2453      resolved_to_zero = (eh != NULL
2454			  && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2455
2456      switch (r_type)
2457	{
2458	case R_386_GOT32X:
2459	case R_386_GOT32:
2460	  /* Relocation is to the entry for this symbol in the global
2461	     offset table.  */
2462	  if (htab->elf.sgot == NULL)
2463	    abort ();
2464
2465	  relative_reloc = FALSE;
2466	  if (h != NULL)
2467	    {
2468	      off = h->got.offset;
2469	      if (RESOLVED_LOCALLY_P (info, h, htab))
2470		{
2471		  /* We must initialize this entry in the global offset
2472		     table.  Since the offset must always be a multiple
2473		     of 4, we use the least significant bit to record
2474		     whether we have initialized it already.
2475
2476		     When doing a dynamic link, we create a .rel.got
2477		     relocation entry to initialize the value.  This
2478		     is done in the finish_dynamic_symbol routine.  */
2479		  if ((off & 1) != 0)
2480		    off &= ~1;
2481		  else
2482		    {
2483		      bfd_put_32 (output_bfd, relocation,
2484				  htab->elf.sgot->contents + off);
2485		      h->got.offset |= 1;
2486
2487		      if (GENERATE_RELATIVE_RELOC_P (info, h))
2488			{
2489			  /* PR ld/21402: If this symbol isn't dynamic
2490			     in PIC, generate R_386_RELATIVE here.  */
2491			  eh->no_finish_dynamic_symbol = 1;
2492			  relative_reloc = TRUE;
2493			}
2494		    }
2495		}
2496	      else
2497		unresolved_reloc = FALSE;
2498	    }
2499	  else
2500	    {
2501	      if (local_got_offsets == NULL)
2502		abort ();
2503
2504	      off = local_got_offsets[r_symndx];
2505
2506	      /* The offset must always be a multiple of 4.  We use
2507		 the least significant bit to record whether we have
2508		 already generated the necessary reloc.  */
2509	      if ((off & 1) != 0)
2510		off &= ~1;
2511	      else
2512		{
2513		  bfd_put_32 (output_bfd, relocation,
2514			      htab->elf.sgot->contents + off);
2515		  local_got_offsets[r_symndx] |= 1;
2516
2517		  if (bfd_link_pic (info))
2518		    relative_reloc = TRUE;
2519		}
2520	    }
2521
2522	  if (relative_reloc)
2523	    {
2524	      asection *s;
2525	      Elf_Internal_Rela outrel;
2526
2527	      s = htab->elf.srelgot;
2528	      if (s == NULL)
2529		abort ();
2530
2531	      outrel.r_offset = (htab->elf.sgot->output_section->vma
2532				 + htab->elf.sgot->output_offset
2533				 + off);
2534	      outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2535	      elf_append_rel (output_bfd, s, &outrel);
2536	    }
2537
2538	  if (off >= (bfd_vma) -2)
2539	    abort ();
2540
2541	  relocation = (htab->elf.sgot->output_section->vma
2542			+ htab->elf.sgot->output_offset + off);
2543	  if (rel->r_offset > 1
2544	      && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2545	      && *(contents + rel->r_offset - 2) != 0x8d)
2546	    {
2547	      if (bfd_link_pic (info))
2548		{
2549		  /* For PIC, disallow R_386_GOT32 without a base
2550		     register, except for "lea foo@GOT, %reg", since
2551		     we don't know what the GOT base is.  */
2552		  const char *name;
2553
2554		disallow_got32:
2555		  if (h == NULL || h->root.root.string == NULL)
2556		    name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2557					     NULL);
2558		  else
2559		    name = h->root.root.string;
2560
2561		  _bfd_error_handler
2562		    /* xgettext:c-format */
2563		    (_("%pB: direct GOT relocation %s against `%s'"
2564		       " without base register can not be used"
2565		       " when making a shared object"),
2566		     input_bfd, howto->name, name);
2567		  bfd_set_error (bfd_error_bad_value);
2568		  return FALSE;
2569		}
2570	    }
2571	  else
2572	    {
2573	      /* Subtract the .got.plt section address only with a base
2574		 register.  */
2575	      relocation -= (htab->elf.sgotplt->output_section->vma
2576			     + htab->elf.sgotplt->output_offset);
2577	    }
2578
2579	  break;
2580
2581	case R_386_GOTOFF:
2582	  /* Relocation is relative to the start of the global offset
2583	     table.  */
2584
2585	  /* Check to make sure it isn't a protected function or data
2586	     symbol for shared library since it may not be local when
2587	     used as function address or with copy relocation.  We also
2588	     need to make sure that a symbol is referenced locally.  */
2589	  if (!bfd_link_executable (info) && h)
2590	    {
2591	      if (!h->def_regular)
2592		{
2593		  const char *v;
2594
2595		  switch (ELF_ST_VISIBILITY (h->other))
2596		    {
2597		    case STV_HIDDEN:
2598		      v = _("hidden symbol");
2599		      break;
2600		    case STV_INTERNAL:
2601		      v = _("internal symbol");
2602		      break;
2603		    case STV_PROTECTED:
2604		      v = _("protected symbol");
2605		      break;
2606		    default:
2607		      v = _("symbol");
2608		      break;
2609		    }
2610
2611		  _bfd_error_handler
2612		    /* xgettext:c-format */
2613		    (_("%pB: relocation R_386_GOTOFF against undefined %s"
2614		       " `%s' can not be used when making a shared object"),
2615		     input_bfd, v, h->root.root.string);
2616		  bfd_set_error (bfd_error_bad_value);
2617		  return FALSE;
2618		}
2619	      else if (!SYMBOL_REFERENCES_LOCAL_P (info, h)
2620		       && (h->type == STT_FUNC
2621			   || h->type == STT_OBJECT)
2622		       && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2623		{
2624		  _bfd_error_handler
2625		    /* xgettext:c-format */
2626		    (_("%pB: relocation R_386_GOTOFF against protected %s"
2627		       " `%s' can not be used when making a shared object"),
2628		     input_bfd,
2629		     h->type == STT_FUNC ? "function" : "data",
2630		     h->root.root.string);
2631		  bfd_set_error (bfd_error_bad_value);
2632		  return FALSE;
2633		}
2634	    }
2635
2636	  /* Note that sgot is not involved in this
2637	     calculation.  We always want the start of .got.plt.  If we
2638	     defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2639	     permitted by the ABI, we might have to change this
2640	     calculation.  */
2641	  relocation -= htab->elf.sgotplt->output_section->vma
2642			+ htab->elf.sgotplt->output_offset;
2643	  break;
2644
2645	case R_386_GOTPC:
2646	  /* Use global offset table as symbol value.  */
2647	  relocation = htab->elf.sgotplt->output_section->vma
2648		       + htab->elf.sgotplt->output_offset;
2649	  unresolved_reloc = FALSE;
2650	  break;
2651
2652	case R_386_PLT32:
2653	  /* Relocation is to the entry for this symbol in the
2654	     procedure linkage table.  */
2655
2656	  /* Resolve a PLT32 reloc against a local symbol directly,
2657	     without using the procedure linkage table.  */
2658	  if (h == NULL)
2659	    break;
2660
2661	  if ((h->plt.offset == (bfd_vma) -1
2662	       && eh->plt_got.offset == (bfd_vma) -1)
2663	      || htab->elf.splt == NULL)
2664	    {
2665	      /* We didn't make a PLT entry for this symbol.  This
2666		 happens when statically linking PIC code, or when
2667		 using -Bsymbolic.  */
2668	      break;
2669	    }
2670
2671	  if (h->plt.offset != (bfd_vma) -1)
2672	    {
2673	      if (htab->plt_second != NULL)
2674		{
2675		  resolved_plt = htab->plt_second;
2676		  plt_offset = eh->plt_second.offset;
2677		}
2678	      else
2679		{
2680		  resolved_plt = htab->elf.splt;
2681		  plt_offset = h->plt.offset;
2682		}
2683	    }
2684	  else
2685	    {
2686	      resolved_plt = htab->plt_got;
2687	      plt_offset = eh->plt_got.offset;
2688	    }
2689
2690	  relocation = (resolved_plt->output_section->vma
2691			+ resolved_plt->output_offset
2692			+ plt_offset);
2693	  unresolved_reloc = FALSE;
2694	  break;
2695
2696	case R_386_SIZE32:
2697	  /* Set to symbol size.  */
2698	  relocation = st_size;
2699	  /* Fall through.  */
2700
2701	case R_386_32:
2702	case R_386_PC32:
2703	  if ((input_section->flags & SEC_ALLOC) == 0
2704	      || is_vxworks_tls)
2705	    break;
2706
2707	  if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type, sec,
2708					     FALSE, resolved_to_zero,
2709					     (r_type == R_386_PC32)))
2710	    {
2711	      Elf_Internal_Rela outrel;
2712	      bfd_boolean skip, relocate;
2713	      asection *sreloc;
2714
2715	      /* When generating a shared object, these relocations
2716		 are copied into the output file to be resolved at run
2717		 time.  */
2718
2719	      skip = FALSE;
2720	      relocate = FALSE;
2721
2722	      outrel.r_offset =
2723		_bfd_elf_section_offset (output_bfd, info, input_section,
2724					 rel->r_offset);
2725	      if (outrel.r_offset == (bfd_vma) -1)
2726		skip = TRUE;
2727	      else if (outrel.r_offset == (bfd_vma) -2)
2728		skip = TRUE, relocate = TRUE;
2729	      outrel.r_offset += (input_section->output_section->vma
2730				  + input_section->output_offset);
2731
2732	      if (skip)
2733		memset (&outrel, 0, sizeof outrel);
2734	      else if (COPY_INPUT_RELOC_P (info, h, r_type))
2735		outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2736	      else
2737		{
2738		  /* This symbol is local, or marked to become local.  */
2739		  relocate = TRUE;
2740		  outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2741		}
2742
2743	      sreloc = elf_section_data (input_section)->sreloc;
2744
2745	      if (sreloc == NULL || sreloc->contents == NULL)
2746		{
2747		  r = bfd_reloc_notsupported;
2748		  goto check_relocation_error;
2749		}
2750
2751	      elf_append_rel (output_bfd, sreloc, &outrel);
2752
2753	      /* If this reloc is against an external symbol, we do
2754		 not want to fiddle with the addend.  Otherwise, we
2755		 need to include the symbol value so that it becomes
2756		 an addend for the dynamic reloc.  */
2757	      if (! relocate)
2758		continue;
2759	    }
2760	  break;
2761
2762	case R_386_TLS_IE:
2763	  if (!bfd_link_executable (info))
2764	    {
2765	      Elf_Internal_Rela outrel;
2766	      asection *sreloc;
2767
2768	      outrel.r_offset = rel->r_offset
2769				+ input_section->output_section->vma
2770				+ input_section->output_offset;
2771	      outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2772	      sreloc = elf_section_data (input_section)->sreloc;
2773	      if (sreloc == NULL)
2774		abort ();
2775	      elf_append_rel (output_bfd, sreloc, &outrel);
2776	    }
2777	  /* Fall through */
2778
2779	case R_386_TLS_GD:
2780	case R_386_TLS_GOTDESC:
2781	case R_386_TLS_DESC_CALL:
2782	case R_386_TLS_IE_32:
2783	case R_386_TLS_GOTIE:
2784	  tls_type = GOT_UNKNOWN;
2785	  if (h == NULL && local_got_offsets)
2786	    tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
2787	  else if (h != NULL)
2788	    tls_type = elf_x86_hash_entry(h)->tls_type;
2789	  if (tls_type == GOT_TLS_IE)
2790	    tls_type = GOT_TLS_IE_NEG;
2791
2792	   r_type_tls = r_type;
2793	  if (! elf_i386_tls_transition (info, input_bfd,
2794					 input_section, contents,
2795					 symtab_hdr, sym_hashes,
2796					 &r_type_tls, tls_type, rel,
2797					 relend, h, r_symndx, TRUE))
2798	    return FALSE;
2799
2800	  if (r_type_tls == R_386_TLS_LE_32)
2801	    {
2802	      BFD_ASSERT (! unresolved_reloc);
2803	      if (r_type == R_386_TLS_GD)
2804		{
2805		  unsigned int type;
2806		  bfd_vma roff;
2807
2808		  /* GD->LE transition.  */
2809		  type = *(contents + rel->r_offset - 2);
2810		  if (type == 0x04)
2811		    {
2812		      /* Change
2813				leal foo@tlsgd(,%ebx,1), %eax
2814				call ___tls_get_addr@PLT
2815			 into:
2816				movl %gs:0, %eax
2817				subl $foo@tpoff, %eax
2818			 (6 byte form of subl).  */
2819		      roff = rel->r_offset + 5;
2820		    }
2821		  else
2822		    {
2823		      /* Change
2824				leal foo@tlsgd(%ebx), %eax
2825				call ___tls_get_addr@PLT
2826				nop
2827			 or
2828				leal foo@tlsgd(%reg), %eax
2829				call *___tls_get_addr@GOT(%reg)
2830				which may be converted to
2831				addr32 call ___tls_get_addr
2832			 into:
2833				movl %gs:0, %eax; subl $foo@tpoff, %eax
2834			 (6 byte form of subl).  */
2835		      roff = rel->r_offset + 6;
2836		    }
2837		  memcpy (contents + roff - 8,
2838			  "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2839		  bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
2840			      contents + roff);
2841		  /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X.  */
2842		  rel++;
2843		  wrel++;
2844		  continue;
2845		}
2846	      else if (r_type == R_386_TLS_GOTDESC)
2847		{
2848		  /* GDesc -> LE transition.
2849		     It's originally something like:
2850		     leal x@tlsdesc(%ebx), %eax
2851
2852		     leal x@ntpoff, %eax
2853
2854		     Registers other than %eax may be set up here.  */
2855
2856		  unsigned int val;
2857		  bfd_vma roff;
2858
2859		  roff = rel->r_offset;
2860		  val = bfd_get_8 (input_bfd, contents + roff - 1);
2861
2862		  /* Now modify the instruction as appropriate.  */
2863		  /* aoliva FIXME: remove the above and xor the byte
2864		     below with 0x86.  */
2865		  bfd_put_8 (output_bfd, val ^ 0x86,
2866			     contents + roff - 1);
2867		  bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2868			      contents + roff);
2869		  continue;
2870		}
2871	      else if (r_type == R_386_TLS_DESC_CALL)
2872		{
2873		  /* GDesc -> LE transition.
2874		     It's originally:
2875		     call *(%eax)
2876		     Turn it into:
2877		     xchg %ax,%ax  */
2878
2879		  bfd_vma roff;
2880
2881		  roff = rel->r_offset;
2882		  bfd_put_8 (output_bfd, 0x66, contents + roff);
2883		  bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2884		  continue;
2885		}
2886	      else if (r_type == R_386_TLS_IE)
2887		{
2888		  unsigned int val;
2889
2890		  /* IE->LE transition:
2891		     Originally it can be one of:
2892		     movl foo, %eax
2893		     movl foo, %reg
2894		     addl foo, %reg
2895		     We change it into:
2896		     movl $foo, %eax
2897		     movl $foo, %reg
2898		     addl $foo, %reg.  */
2899		  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2900		  if (val == 0xa1)
2901		    {
2902		      /* movl foo, %eax.  */
2903		      bfd_put_8 (output_bfd, 0xb8,
2904				 contents + rel->r_offset - 1);
2905		    }
2906		  else
2907		    {
2908		      unsigned int type;
2909
2910		      type = bfd_get_8 (input_bfd,
2911					contents + rel->r_offset - 2);
2912		      switch (type)
2913			{
2914			case 0x8b:
2915			  /* movl */
2916			  bfd_put_8 (output_bfd, 0xc7,
2917				     contents + rel->r_offset - 2);
2918			  bfd_put_8 (output_bfd,
2919				     0xc0 | ((val >> 3) & 7),
2920				     contents + rel->r_offset - 1);
2921			  break;
2922			case 0x03:
2923			  /* addl */
2924			  bfd_put_8 (output_bfd, 0x81,
2925				     contents + rel->r_offset - 2);
2926			  bfd_put_8 (output_bfd,
2927				     0xc0 | ((val >> 3) & 7),
2928				     contents + rel->r_offset - 1);
2929			  break;
2930			default:
2931			  BFD_FAIL ();
2932			  break;
2933			}
2934		    }
2935		  bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2936			      contents + rel->r_offset);
2937		  continue;
2938		}
2939	      else
2940		{
2941		  unsigned int val, type;
2942
2943		  /* {IE_32,GOTIE}->LE transition:
2944		     Originally it can be one of:
2945		     subl foo(%reg1), %reg2
2946		     movl foo(%reg1), %reg2
2947		     addl foo(%reg1), %reg2
2948		     We change it into:
2949		     subl $foo, %reg2
2950		     movl $foo, %reg2 (6 byte form)
2951		     addl $foo, %reg2.  */
2952		  type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2953		  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2954		  if (type == 0x8b)
2955		    {
2956		      /* movl */
2957		      bfd_put_8 (output_bfd, 0xc7,
2958				 contents + rel->r_offset - 2);
2959		      bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2960				 contents + rel->r_offset - 1);
2961		    }
2962		  else if (type == 0x2b)
2963		    {
2964		      /* subl */
2965		      bfd_put_8 (output_bfd, 0x81,
2966				 contents + rel->r_offset - 2);
2967		      bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2968				 contents + rel->r_offset - 1);
2969		    }
2970		  else if (type == 0x03)
2971		    {
2972		      /* addl */
2973		      bfd_put_8 (output_bfd, 0x81,
2974				 contents + rel->r_offset - 2);
2975		      bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2976				 contents + rel->r_offset - 1);
2977		    }
2978		  else
2979		    BFD_FAIL ();
2980		  if (r_type == R_386_TLS_GOTIE)
2981		    bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2982				contents + rel->r_offset);
2983		  else
2984		    bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
2985				contents + rel->r_offset);
2986		  continue;
2987		}
2988	    }
2989
2990	  if (htab->elf.sgot == NULL)
2991	    abort ();
2992
2993	  if (h != NULL)
2994	    {
2995	      off = h->got.offset;
2996	      offplt = elf_x86_hash_entry (h)->tlsdesc_got;
2997	    }
2998	  else
2999	    {
3000	      if (local_got_offsets == NULL)
3001		abort ();
3002
3003	      off = local_got_offsets[r_symndx];
3004	      offplt = local_tlsdesc_gotents[r_symndx];
3005	    }
3006
3007	  if ((off & 1) != 0)
3008	    off &= ~1;
3009	  else
3010	    {
3011	      Elf_Internal_Rela outrel;
3012	      int dr_type;
3013	      asection *sreloc;
3014
3015	      if (htab->elf.srelgot == NULL)
3016		abort ();
3017
3018	      indx = h && h->dynindx != -1 ? h->dynindx : 0;
3019
3020	      if (GOT_TLS_GDESC_P (tls_type))
3021		{
3022		  bfd_byte *loc;
3023		  outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3024		  BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3025			      <= htab->elf.sgotplt->size);
3026		  outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3027				     + htab->elf.sgotplt->output_offset
3028				     + offplt
3029				     + htab->sgotplt_jump_table_size);
3030		  sreloc = htab->elf.srelplt;
3031		  loc = sreloc->contents;
3032		  loc += (htab->next_tls_desc_index++
3033			  * sizeof (Elf32_External_Rel));
3034		  BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3035			      <= sreloc->contents + sreloc->size);
3036		  bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3037		  if (indx == 0)
3038		    {
3039		      BFD_ASSERT (! unresolved_reloc);
3040		      bfd_put_32 (output_bfd,
3041				  relocation - _bfd_x86_elf_dtpoff_base (info),
3042				  htab->elf.sgotplt->contents + offplt
3043				  + htab->sgotplt_jump_table_size + 4);
3044		    }
3045		  else
3046		    {
3047		      bfd_put_32 (output_bfd, 0,
3048				  htab->elf.sgotplt->contents + offplt
3049				  + htab->sgotplt_jump_table_size + 4);
3050		    }
3051		}
3052
3053	      sreloc = htab->elf.srelgot;
3054
3055	      outrel.r_offset = (htab->elf.sgot->output_section->vma
3056				 + htab->elf.sgot->output_offset + off);
3057
3058	      if (GOT_TLS_GD_P (tls_type))
3059		dr_type = R_386_TLS_DTPMOD32;
3060	      else if (GOT_TLS_GDESC_P (tls_type))
3061		goto dr_done;
3062	      else if (tls_type == GOT_TLS_IE_POS)
3063		dr_type = R_386_TLS_TPOFF;
3064	      else
3065		dr_type = R_386_TLS_TPOFF32;
3066
3067	      if (dr_type == R_386_TLS_TPOFF && indx == 0)
3068		bfd_put_32 (output_bfd,
3069			    relocation - _bfd_x86_elf_dtpoff_base (info),
3070			    htab->elf.sgot->contents + off);
3071	      else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3072		bfd_put_32 (output_bfd,
3073			    _bfd_x86_elf_dtpoff_base (info) - relocation,
3074			    htab->elf.sgot->contents + off);
3075	      else if (dr_type != R_386_TLS_DESC)
3076		bfd_put_32 (output_bfd, 0,
3077			    htab->elf.sgot->contents + off);
3078	      outrel.r_info = ELF32_R_INFO (indx, dr_type);
3079
3080	      elf_append_rel (output_bfd, sreloc, &outrel);
3081
3082	      if (GOT_TLS_GD_P (tls_type))
3083		{
3084		  if (indx == 0)
3085		    {
3086		      BFD_ASSERT (! unresolved_reloc);
3087		      bfd_put_32 (output_bfd,
3088				  relocation - _bfd_x86_elf_dtpoff_base (info),
3089				  htab->elf.sgot->contents + off + 4);
3090		    }
3091		  else
3092		    {
3093		      bfd_put_32 (output_bfd, 0,
3094				  htab->elf.sgot->contents + off + 4);
3095		      outrel.r_info = ELF32_R_INFO (indx,
3096						    R_386_TLS_DTPOFF32);
3097		      outrel.r_offset += 4;
3098		      elf_append_rel (output_bfd, sreloc, &outrel);
3099		    }
3100		}
3101	      else if (tls_type == GOT_TLS_IE_BOTH)
3102		{
3103		  bfd_put_32 (output_bfd,
3104			      (indx == 0
3105			       ? relocation - _bfd_x86_elf_dtpoff_base (info)
3106			       : 0),
3107			      htab->elf.sgot->contents + off + 4);
3108		  outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3109		  outrel.r_offset += 4;
3110		  elf_append_rel (output_bfd, sreloc, &outrel);
3111		}
3112
3113	    dr_done:
3114	      if (h != NULL)
3115		h->got.offset |= 1;
3116	      else
3117		local_got_offsets[r_symndx] |= 1;
3118	    }
3119
3120	  if (off >= (bfd_vma) -2
3121	      && ! GOT_TLS_GDESC_P (tls_type))
3122	    abort ();
3123	  if (r_type_tls == R_386_TLS_GOTDESC
3124	      || r_type_tls == R_386_TLS_DESC_CALL)
3125	    {
3126	      relocation = htab->sgotplt_jump_table_size + offplt;
3127	      unresolved_reloc = FALSE;
3128	    }
3129	  else if (r_type_tls == r_type)
3130	    {
3131	      bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
3132			      + htab->elf.sgotplt->output_offset;
3133	      relocation = htab->elf.sgot->output_section->vma
3134		+ htab->elf.sgot->output_offset + off - g_o_t;
3135	      if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3136		  && tls_type == GOT_TLS_IE_BOTH)
3137		relocation += 4;
3138	      if (r_type == R_386_TLS_IE)
3139		relocation += g_o_t;
3140	      unresolved_reloc = FALSE;
3141	    }
3142	  else if (r_type == R_386_TLS_GD)
3143	    {
3144	      unsigned int val, type;
3145	      bfd_vma roff;
3146
3147	      /* GD->IE transition.  */
3148	      type = *(contents + rel->r_offset - 2);
3149	      val = *(contents + rel->r_offset - 1);
3150	      if (type == 0x04)
3151		{
3152		  /* Change
3153			leal foo@tlsgd(,%ebx,1), %eax
3154			call ___tls_get_addr@PLT
3155		     into:
3156			movl %gs:0, %eax
3157			subl $foo@gottpoff(%ebx), %eax.  */
3158		  val >>= 3;
3159		  roff = rel->r_offset - 3;
3160		}
3161	      else
3162		{
3163		  /* Change
3164			leal foo@tlsgd(%ebx), %eax
3165			call ___tls_get_addr@PLT
3166			nop
3167		     or
3168			leal foo@tlsgd(%reg), %eax
3169			call *___tls_get_addr@GOT(%reg)
3170			which may be converted to
3171			addr32 call ___tls_get_addr
3172		     into:
3173			movl %gs:0, %eax;
3174			subl $foo@gottpoff(%reg), %eax.  */
3175		  roff = rel->r_offset - 2;
3176		}
3177	      memcpy (contents + roff,
3178		      "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3179	      contents[roff + 7] = 0x80 | (val & 7);
3180	      /* If foo is used only with foo@gotntpoff(%reg) and
3181		 foo@indntpoff, but not with foo@gottpoff(%reg), change
3182		 subl $foo@gottpoff(%reg), %eax
3183		 into:
3184		 addl $foo@gotntpoff(%reg), %eax.  */
3185	      if (tls_type == GOT_TLS_IE_POS)
3186		contents[roff + 6] = 0x03;
3187	      bfd_put_32 (output_bfd,
3188			  htab->elf.sgot->output_section->vma
3189			  + htab->elf.sgot->output_offset + off
3190			  - htab->elf.sgotplt->output_section->vma
3191			  - htab->elf.sgotplt->output_offset,
3192			  contents + roff + 8);
3193	      /* Skip R_386_PLT32 and R_386_GOT32X.  */
3194	      rel++;
3195	      wrel++;
3196	      continue;
3197	    }
3198	  else if (r_type == R_386_TLS_GOTDESC)
3199	    {
3200	      /* GDesc -> IE transition.
3201		 It's originally something like:
3202		 leal x@tlsdesc(%ebx), %eax
3203
3204		 Change it to:
3205		 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3206		 or:
3207		 movl x@gottpoff(%ebx), %eax # before negl %eax
3208
3209		 Registers other than %eax may be set up here.  */
3210
3211	      bfd_vma roff;
3212
3213	      /* First, make sure it's a leal adding ebx to a 32-bit
3214		 offset into any register, although it's probably
3215		 almost always going to be eax.  */
3216	      roff = rel->r_offset;
3217
3218	      /* Now modify the instruction as appropriate.  */
3219	      /* To turn a leal into a movl in the form we use it, it
3220		 suffices to change the first byte from 0x8d to 0x8b.
3221		 aoliva FIXME: should we decide to keep the leal, all
3222		 we have to do is remove the statement below, and
3223		 adjust the relaxation of R_386_TLS_DESC_CALL.  */
3224	      bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3225
3226	      if (tls_type == GOT_TLS_IE_BOTH)
3227		off += 4;
3228
3229	      bfd_put_32 (output_bfd,
3230			  htab->elf.sgot->output_section->vma
3231			  + htab->elf.sgot->output_offset + off
3232			  - htab->elf.sgotplt->output_section->vma
3233			  - htab->elf.sgotplt->output_offset,
3234			  contents + roff);
3235	      continue;
3236	    }
3237	  else if (r_type == R_386_TLS_DESC_CALL)
3238	    {
3239	      /* GDesc -> IE transition.
3240		 It's originally:
3241		 call *(%eax)
3242
3243		 Change it to:
3244		 xchg %ax,%ax
3245		 or
3246		 negl %eax
3247		 depending on how we transformed the TLS_GOTDESC above.
3248	      */
3249
3250	      bfd_vma roff;
3251
3252	      roff = rel->r_offset;
3253
3254	      /* Now modify the instruction as appropriate.  */
3255	      if (tls_type != GOT_TLS_IE_NEG)
3256		{
3257		  /* xchg %ax,%ax */
3258		  bfd_put_8 (output_bfd, 0x66, contents + roff);
3259		  bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3260		}
3261	      else
3262		{
3263		  /* negl %eax */
3264		  bfd_put_8 (output_bfd, 0xf7, contents + roff);
3265		  bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3266		}
3267
3268	      continue;
3269	    }
3270	  else
3271	    BFD_ASSERT (FALSE);
3272	  break;
3273
3274	case R_386_TLS_LDM:
3275	  if (! elf_i386_tls_transition (info, input_bfd,
3276					 input_section, contents,
3277					 symtab_hdr, sym_hashes,
3278					 &r_type, GOT_UNKNOWN, rel,
3279					 relend, h, r_symndx, TRUE))
3280	    return FALSE;
3281
3282	  if (r_type != R_386_TLS_LDM)
3283	    {
3284	      /* LD->LE transition.  Change
3285			leal foo@tlsldm(%ebx) %eax
3286			call ___tls_get_addr@PLT
3287		 into:
3288			movl %gs:0, %eax
3289			nop
3290			leal 0(%esi,1), %esi
3291		 or change
3292			leal foo@tlsldm(%reg) %eax
3293			call *___tls_get_addr@GOT(%reg)
3294			which may be converted to
3295			addr32 call ___tls_get_addr
3296		 into:
3297			movl %gs:0, %eax
3298			leal 0(%esi), %esi  */
3299	      BFD_ASSERT (r_type == R_386_TLS_LE_32);
3300	      if (*(contents + rel->r_offset + 4) == 0xff
3301		  || *(contents + rel->r_offset + 4) == 0x67)
3302		memcpy (contents + rel->r_offset - 2,
3303			"\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
3304	      else
3305		memcpy (contents + rel->r_offset - 2,
3306			"\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3307	      /* Skip R_386_PC32/R_386_PLT32.  */
3308	      rel++;
3309	      wrel++;
3310	      continue;
3311	    }
3312
3313	  if (htab->elf.sgot == NULL)
3314	    abort ();
3315
3316	  off = htab->tls_ld_or_ldm_got.offset;
3317	  if (off & 1)
3318	    off &= ~1;
3319	  else
3320	    {
3321	      Elf_Internal_Rela outrel;
3322
3323	      if (htab->elf.srelgot == NULL)
3324		abort ();
3325
3326	      outrel.r_offset = (htab->elf.sgot->output_section->vma
3327				 + htab->elf.sgot->output_offset + off);
3328
3329	      bfd_put_32 (output_bfd, 0,
3330			  htab->elf.sgot->contents + off);
3331	      bfd_put_32 (output_bfd, 0,
3332			  htab->elf.sgot->contents + off + 4);
3333	      outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3334	      elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
3335	      htab->tls_ld_or_ldm_got.offset |= 1;
3336	    }
3337	  relocation = htab->elf.sgot->output_section->vma
3338		       + htab->elf.sgot->output_offset + off
3339		       - htab->elf.sgotplt->output_section->vma
3340		       - htab->elf.sgotplt->output_offset;
3341	  unresolved_reloc = FALSE;
3342	  break;
3343
3344	case R_386_TLS_LDO_32:
3345	  if (!bfd_link_executable (info)
3346	      || (input_section->flags & SEC_CODE) == 0)
3347	    relocation -= _bfd_x86_elf_dtpoff_base (info);
3348	  else
3349	    /* When converting LDO to LE, we must negate.  */
3350	    relocation = -elf_i386_tpoff (info, relocation);
3351	  break;
3352
3353	case R_386_TLS_LE_32:
3354	case R_386_TLS_LE:
3355	  if (!bfd_link_executable (info))
3356	    {
3357	      Elf_Internal_Rela outrel;
3358	      asection *sreloc;
3359
3360	      outrel.r_offset = rel->r_offset
3361				+ input_section->output_section->vma
3362				+ input_section->output_offset;
3363	      if (h != NULL && h->dynindx != -1)
3364		indx = h->dynindx;
3365	      else
3366		indx = 0;
3367	      if (r_type == R_386_TLS_LE_32)
3368		outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3369	      else
3370		outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3371	      sreloc = elf_section_data (input_section)->sreloc;
3372	      if (sreloc == NULL)
3373		abort ();
3374	      elf_append_rel (output_bfd, sreloc, &outrel);
3375	      if (indx)
3376		continue;
3377	      else if (r_type == R_386_TLS_LE_32)
3378		relocation = _bfd_x86_elf_dtpoff_base (info) - relocation;
3379	      else
3380		relocation -= _bfd_x86_elf_dtpoff_base (info);
3381	    }
3382	  else if (r_type == R_386_TLS_LE_32)
3383	    relocation = elf_i386_tpoff (info, relocation);
3384	  else
3385	    relocation = -elf_i386_tpoff (info, relocation);
3386	  break;
3387
3388	default:
3389	  break;
3390	}
3391
3392      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3393	 because such sections are not SEC_ALLOC and thus ld.so will
3394	 not process them.  */
3395      if (unresolved_reloc
3396	  && !((input_section->flags & SEC_DEBUGGING) != 0
3397	       && h->def_dynamic)
3398	  && _bfd_elf_section_offset (output_bfd, info, input_section,
3399				      rel->r_offset) != (bfd_vma) -1)
3400	{
3401	  _bfd_error_handler
3402	    /* xgettext:c-format */
3403	    (_("%pB(%pA+%#" PRIx64 "): unresolvable %s relocation against symbol `%s'"),
3404	     input_bfd,
3405	     input_section,
3406	     (uint64_t) rel->r_offset,
3407	     howto->name,
3408	     h->root.root.string);
3409	  return FALSE;
3410	}
3411
3412    do_relocation:
3413      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3414				    contents, rel->r_offset,
3415				    relocation, 0);
3416
3417    check_relocation_error:
3418      if (r != bfd_reloc_ok)
3419	{
3420	  const char *name;
3421
3422	  if (h != NULL)
3423	    name = h->root.root.string;
3424	  else
3425	    {
3426	      name = bfd_elf_string_from_elf_section (input_bfd,
3427						      symtab_hdr->sh_link,
3428						      sym->st_name);
3429	      if (name == NULL)
3430		return FALSE;
3431	      if (*name == '\0')
3432		name = bfd_section_name (sec);
3433	    }
3434
3435	  if (r == bfd_reloc_overflow)
3436	    (*info->callbacks->reloc_overflow)
3437	      (info, (h ? &h->root : NULL), name, howto->name,
3438	       (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3439	  else
3440	    {
3441	      _bfd_error_handler
3442		/* xgettext:c-format */
3443		(_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3444		 input_bfd, input_section,
3445		 (uint64_t) rel->r_offset, name, (int) r);
3446	      return FALSE;
3447	    }
3448	}
3449
3450      if (wrel != rel)
3451	*wrel = *rel;
3452    }
3453
3454  if (wrel != rel)
3455    {
3456      Elf_Internal_Shdr *rel_hdr;
3457      size_t deleted = rel - wrel;
3458
3459      rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3460      rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3461      if (rel_hdr->sh_size == 0)
3462	{
3463	  /* It is too late to remove an empty reloc section.  Leave
3464	     one NONE reloc.
3465	     ??? What is wrong with an empty section???  */
3466	  rel_hdr->sh_size = rel_hdr->sh_entsize;
3467	  deleted -= 1;
3468	}
3469      rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3470      rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3471      input_section->reloc_count -= deleted;
3472    }
3473
3474  return TRUE;
3475}
3476
3477/* Finish up dynamic symbol handling.  We set the contents of various
3478   dynamic sections here.  */
3479
3480static bfd_boolean
3481elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3482				struct bfd_link_info *info,
3483				struct elf_link_hash_entry *h,
3484				Elf_Internal_Sym *sym)
3485{
3486  struct elf_x86_link_hash_table *htab;
3487  unsigned plt_entry_size;
3488  struct elf_x86_link_hash_entry *eh;
3489  bfd_boolean local_undefweak;
3490  bfd_boolean use_plt_second;
3491
3492  htab = elf_x86_hash_table (info, I386_ELF_DATA);
3493  if (htab == NULL)
3494    return FALSE;
3495
3496  plt_entry_size = htab->plt.plt_entry_size;
3497
3498  /* Use the second PLT section only if there is .plt section.  */
3499  use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3500
3501  eh = (struct elf_x86_link_hash_entry *) h;
3502  if (eh->no_finish_dynamic_symbol)
3503    abort ();
3504
3505  /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3506     resolved undefined weak symbols in executable so that their
3507     references have value 0 at run-time.  */
3508  local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3509
3510  if (h->plt.offset != (bfd_vma) -1)
3511    {
3512      bfd_vma plt_index, plt_offset;
3513      bfd_vma got_offset;
3514      Elf_Internal_Rela rel;
3515      bfd_byte *loc;
3516      asection *plt, *resolved_plt, *gotplt, *relplt;
3517
3518      /* When building a static executable, use .iplt, .igot.plt and
3519	 .rel.iplt sections for STT_GNU_IFUNC symbols.  */
3520      if (htab->elf.splt != NULL)
3521	{
3522	  plt = htab->elf.splt;
3523	  gotplt = htab->elf.sgotplt;
3524	  relplt = htab->elf.srelplt;
3525	}
3526      else
3527	{
3528	  plt = htab->elf.iplt;
3529	  gotplt = htab->elf.igotplt;
3530	  relplt = htab->elf.irelplt;
3531	}
3532
3533      VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3534
3535      /* Get the index in the procedure linkage table which
3536	 corresponds to this symbol.  This is the index of this symbol
3537	 in all the symbols for which we are making plt entries.  The
3538	 first entry in the procedure linkage table is reserved.
3539
3540	 Get the offset into the .got table of the entry that
3541	 corresponds to this function.  Each .got entry is 4 bytes.
3542	 The first three are reserved.
3543
3544	 For static executables, we don't reserve anything.  */
3545
3546      if (plt == htab->elf.splt)
3547	{
3548	  got_offset = (h->plt.offset / plt_entry_size
3549			- htab->plt.has_plt0);
3550	  got_offset = (got_offset + 3) * 4;
3551	}
3552      else
3553	{
3554	  got_offset = h->plt.offset / plt_entry_size;
3555	  got_offset = got_offset * 4;
3556	}
3557
3558      /* Fill in the entry in the procedure linkage table and update
3559	 the first slot.  */
3560      memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3561	      plt_entry_size);
3562
3563      if (use_plt_second)
3564	{
3565	  const bfd_byte *plt_entry;
3566	  if (bfd_link_pic (info))
3567	    plt_entry = htab->non_lazy_plt->pic_plt_entry;
3568	  else
3569	    plt_entry = htab->non_lazy_plt->plt_entry;
3570	  memcpy (htab->plt_second->contents + eh->plt_second.offset,
3571		  plt_entry, htab->non_lazy_plt->plt_entry_size);
3572
3573	  resolved_plt = htab->plt_second;
3574	  plt_offset = eh->plt_second.offset;
3575	}
3576      else
3577	{
3578	  resolved_plt = plt;
3579	  plt_offset = h->plt.offset;
3580	}
3581
3582      if (! bfd_link_pic (info))
3583	{
3584	  bfd_put_32 (output_bfd,
3585		      (gotplt->output_section->vma
3586		       + gotplt->output_offset
3587		       + got_offset),
3588		      resolved_plt->contents + plt_offset
3589		      + htab->plt.plt_got_offset);
3590
3591	  if (htab->elf.target_os == is_vxworks)
3592	    {
3593	      int s, k, reloc_index;
3594
3595	      /* Create the R_386_32 relocation referencing the GOT
3596		 for this PLT entry.  */
3597
3598	      /* S: Current slot number (zero-based).  */
3599	      s = ((h->plt.offset - htab->plt.plt_entry_size)
3600		   / htab->plt.plt_entry_size);
3601	      /* K: Number of relocations for PLTResolve. */
3602	      if (bfd_link_pic (info))
3603		k = PLTRESOLVE_RELOCS_SHLIB;
3604	      else
3605		k = PLTRESOLVE_RELOCS;
3606	      /* Skip the PLTresolve relocations, and the relocations for
3607		 the other PLT slots. */
3608	      reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3609	      loc = (htab->srelplt2->contents + reloc_index
3610		     * sizeof (Elf32_External_Rel));
3611
3612	      rel.r_offset = (plt->output_section->vma
3613			      + plt->output_offset
3614			      + h->plt.offset + 2),
3615	      rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3616	      bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3617
3618	      /* Create the R_386_32 relocation referencing the beginning of
3619		 the PLT for this GOT entry.  */
3620	      rel.r_offset = (htab->elf.sgotplt->output_section->vma
3621			      + htab->elf.sgotplt->output_offset
3622			      + got_offset);
3623	      rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3624	      bfd_elf32_swap_reloc_out (output_bfd, &rel,
3625					loc + sizeof (Elf32_External_Rel));
3626	    }
3627	}
3628      else
3629	{
3630	  bfd_put_32 (output_bfd, got_offset,
3631		      resolved_plt->contents + plt_offset
3632		      + htab->plt.plt_got_offset);
3633	}
3634
3635      /* Fill in the entry in the global offset table.  Leave the entry
3636	 as zero for undefined weak symbol in PIE.  No PLT relocation
3637	 against undefined weak symbol in PIE.  */
3638      if (!local_undefweak)
3639	{
3640	  if (htab->plt.has_plt0)
3641	    bfd_put_32 (output_bfd,
3642			(plt->output_section->vma
3643			 + plt->output_offset
3644			 + h->plt.offset
3645			 + htab->lazy_plt->plt_lazy_offset),
3646			gotplt->contents + got_offset);
3647
3648	  /* Fill in the entry in the .rel.plt section.  */
3649	  rel.r_offset = (gotplt->output_section->vma
3650			  + gotplt->output_offset
3651			  + got_offset);
3652	  if (PLT_LOCAL_IFUNC_P (info, h))
3653	    {
3654	      info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3655				      h->root.root.string,
3656				      h->root.u.def.section->owner);
3657
3658	      /* If an STT_GNU_IFUNC symbol is locally defined, generate
3659		 R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
3660		 in the .got.plt section.  */
3661	      bfd_put_32 (output_bfd,
3662			  (h->root.u.def.value
3663			   + h->root.u.def.section->output_section->vma
3664			   + h->root.u.def.section->output_offset),
3665			  gotplt->contents + got_offset);
3666	      rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3667	      /* R_386_IRELATIVE comes last.  */
3668	      plt_index = htab->next_irelative_index--;
3669	    }
3670	  else
3671	    {
3672	      rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3673	      plt_index = htab->next_jump_slot_index++;
3674	    }
3675
3676	  loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
3677	  bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3678
3679	  /* Don't fill the second and third slots in PLT entry for
3680	     static executables nor without PLT0.  */
3681	  if (plt == htab->elf.splt && htab->plt.has_plt0)
3682	    {
3683	      bfd_put_32 (output_bfd,
3684			  plt_index * sizeof (Elf32_External_Rel),
3685			  plt->contents + h->plt.offset
3686			  + htab->lazy_plt->plt_reloc_offset);
3687	      bfd_put_32 (output_bfd,
3688			  - (h->plt.offset
3689			     + htab->lazy_plt->plt_plt_offset + 4),
3690			  (plt->contents + h->plt.offset
3691			   + htab->lazy_plt->plt_plt_offset));
3692	    }
3693	}
3694    }
3695  else if (eh->plt_got.offset != (bfd_vma) -1)
3696    {
3697      bfd_vma got_offset, plt_offset;
3698      asection *plt, *got, *gotplt;
3699      const bfd_byte *got_plt_entry;
3700
3701      /* Set the entry in the GOT procedure linkage table.  */
3702      plt = htab->plt_got;
3703      got = htab->elf.sgot;
3704      gotplt = htab->elf.sgotplt;
3705      got_offset = h->got.offset;
3706
3707      if (got_offset == (bfd_vma) -1
3708	  || plt == NULL
3709	  || got == NULL
3710	  || gotplt == NULL)
3711	abort ();
3712
3713      /* Fill in the entry in the GOT procedure linkage table.  */
3714      if (! bfd_link_pic (info))
3715	{
3716	  got_plt_entry = htab->non_lazy_plt->plt_entry;
3717	  got_offset += got->output_section->vma + got->output_offset;
3718	}
3719      else
3720	{
3721	  got_plt_entry = htab->non_lazy_plt->pic_plt_entry;
3722	  got_offset += (got->output_section->vma
3723			 + got->output_offset
3724			 - gotplt->output_section->vma
3725			 - gotplt->output_offset);
3726	}
3727
3728      plt_offset = eh->plt_got.offset;
3729      memcpy (plt->contents + plt_offset, got_plt_entry,
3730	      htab->non_lazy_plt->plt_entry_size);
3731      bfd_put_32 (output_bfd, got_offset,
3732		  (plt->contents + plt_offset
3733		   + htab->non_lazy_plt->plt_got_offset));
3734    }
3735
3736  if (!local_undefweak
3737      && !h->def_regular
3738      && (h->plt.offset != (bfd_vma) -1
3739	  || eh->plt_got.offset != (bfd_vma) -1))
3740    {
3741      /* Mark the symbol as undefined, rather than as defined in
3742	 the .plt section.  Leave the value if there were any
3743	 relocations where pointer equality matters (this is a clue
3744	 for the dynamic linker, to make function pointer
3745	 comparisons work between an application and shared
3746	 library), otherwise set it to zero.  If a function is only
3747	 called from a binary, there is no need to slow down
3748	 shared libraries because of that.  */
3749      sym->st_shndx = SHN_UNDEF;
3750      if (!h->pointer_equality_needed)
3751	sym->st_value = 0;
3752    }
3753
3754  _bfd_x86_elf_link_fixup_ifunc_symbol (info, htab, h, sym);
3755
3756  /* Don't generate dynamic GOT relocation against undefined weak
3757     symbol in executable.  */
3758  if (h->got.offset != (bfd_vma) -1
3759      && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry(h)->tls_type)
3760      && (elf_x86_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
3761      && !local_undefweak)
3762    {
3763      Elf_Internal_Rela rel;
3764      asection *relgot = htab->elf.srelgot;
3765
3766      /* This symbol has an entry in the global offset table.  Set it
3767	 up.  */
3768
3769      if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3770	abort ();
3771
3772      rel.r_offset = (htab->elf.sgot->output_section->vma
3773		      + htab->elf.sgot->output_offset
3774		      + (h->got.offset & ~(bfd_vma) 1));
3775
3776      /* If this is a static link, or it is a -Bsymbolic link and the
3777	 symbol is defined locally or was forced to be local because
3778	 of a version file, we just want to emit a RELATIVE reloc.
3779	 The entry in the global offset table will already have been
3780	 initialized in the relocate_section function.  */
3781      if (h->def_regular
3782	  && h->type == STT_GNU_IFUNC)
3783	{
3784	  if (h->plt.offset == (bfd_vma) -1)
3785	    {
3786	      /* STT_GNU_IFUNC is referenced without PLT.  */
3787	      if (htab->elf.splt == NULL)
3788		{
3789		  /* use .rel[a].iplt section to store .got relocations
3790		     in static executable.  */
3791		  relgot = htab->elf.irelplt;
3792		}
3793	      if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3794		{
3795		  info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3796					  h->root.root.string,
3797					  h->root.u.def.section->owner);
3798
3799		  bfd_put_32 (output_bfd,
3800			      (h->root.u.def.value
3801			       + h->root.u.def.section->output_section->vma
3802			       + h->root.u.def.section->output_offset),
3803			      htab->elf.sgot->contents + h->got.offset);
3804		  rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3805		}
3806	      else
3807		goto do_glob_dat;
3808	    }
3809	  else if (bfd_link_pic (info))
3810	    {
3811	      /* Generate R_386_GLOB_DAT.  */
3812	      goto do_glob_dat;
3813	    }
3814	  else
3815	    {
3816	      asection *plt;
3817	      bfd_vma plt_offset;
3818
3819	      if (!h->pointer_equality_needed)
3820		abort ();
3821
3822	      /* For non-shared object, we can't use .got.plt, which
3823		 contains the real function addres if we need pointer
3824		 equality.  We load the GOT entry with the PLT entry.  */
3825	      if (htab->plt_second != NULL)
3826		{
3827		  plt = htab->plt_second;
3828		  plt_offset = eh->plt_second.offset;
3829		}
3830	      else
3831		{
3832		  plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3833		  plt_offset = h->plt.offset;
3834		}
3835	      bfd_put_32 (output_bfd,
3836			  (plt->output_section->vma
3837			   + plt->output_offset + plt_offset),
3838			  htab->elf.sgot->contents + h->got.offset);
3839	      return TRUE;
3840	    }
3841	}
3842      else if (bfd_link_pic (info)
3843	       && SYMBOL_REFERENCES_LOCAL_P (info, h))
3844	{
3845	  BFD_ASSERT((h->got.offset & 1) != 0);
3846	  rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3847	}
3848      else
3849	{
3850	  BFD_ASSERT((h->got.offset & 1) == 0);
3851	do_glob_dat:
3852	  bfd_put_32 (output_bfd, (bfd_vma) 0,
3853		      htab->elf.sgot->contents + h->got.offset);
3854	  rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3855	}
3856
3857      elf_append_rel (output_bfd, relgot, &rel);
3858    }
3859
3860  if (h->needs_copy)
3861    {
3862      Elf_Internal_Rela rel;
3863      asection *s;
3864
3865      /* This symbol needs a copy reloc.  Set it up.  */
3866      VERIFY_COPY_RELOC (h, htab)
3867
3868      rel.r_offset = (h->root.u.def.value
3869		      + h->root.u.def.section->output_section->vma
3870		      + h->root.u.def.section->output_offset);
3871      rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3872      if (h->root.u.def.section == htab->elf.sdynrelro)
3873	s = htab->elf.sreldynrelro;
3874      else
3875	s = htab->elf.srelbss;
3876      elf_append_rel (output_bfd, s, &rel);
3877    }
3878
3879  return TRUE;
3880}
3881
3882/* Finish up local dynamic symbol handling.  We set the contents of
3883   various dynamic sections here.  */
3884
3885static bfd_boolean
3886elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
3887{
3888  struct elf_link_hash_entry *h
3889    = (struct elf_link_hash_entry *) *slot;
3890  struct bfd_link_info *info
3891    = (struct bfd_link_info *) inf;
3892
3893  return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
3894					 h, NULL);
3895}
3896
3897/* Finish up undefined weak symbol handling in PIE.  Fill its PLT entry
3898   here since undefined weak symbol may not be dynamic and may not be
3899   called for elf_i386_finish_dynamic_symbol.  */
3900
3901static bfd_boolean
3902elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
3903				      void *inf)
3904{
3905  struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
3906  struct bfd_link_info *info = (struct bfd_link_info *) inf;
3907
3908  if (h->root.type != bfd_link_hash_undefweak
3909      || h->dynindx != -1)
3910    return TRUE;
3911
3912  return elf_i386_finish_dynamic_symbol (info->output_bfd,
3913					 info, h, NULL);
3914}
3915
3916/* Used to decide how to sort relocs in an optimal manner for the
3917   dynamic linker, before writing them out.  */
3918
3919static enum elf_reloc_type_class
3920elf_i386_reloc_type_class (const struct bfd_link_info *info,
3921			   const asection *rel_sec ATTRIBUTE_UNUSED,
3922			   const Elf_Internal_Rela *rela)
3923{
3924  bfd *abfd = info->output_bfd;
3925  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3926  struct elf_link_hash_table *htab = elf_hash_table (info);
3927
3928  if (htab->dynsym != NULL
3929      && htab->dynsym->contents != NULL)
3930    {
3931      /* Check relocation against STT_GNU_IFUNC symbol if there are
3932	 dynamic symbols.  */
3933      unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3934      if (r_symndx != STN_UNDEF)
3935	{
3936	  Elf_Internal_Sym sym;
3937	  if (!bed->s->swap_symbol_in (abfd,
3938				       (htab->dynsym->contents
3939					+ r_symndx * sizeof (Elf32_External_Sym)),
3940				       0, &sym))
3941	    abort ();
3942
3943	  if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3944	    return reloc_class_ifunc;
3945	}
3946    }
3947
3948  switch (ELF32_R_TYPE (rela->r_info))
3949    {
3950    case R_386_IRELATIVE:
3951      return reloc_class_ifunc;
3952    case R_386_RELATIVE:
3953      return reloc_class_relative;
3954    case R_386_JUMP_SLOT:
3955      return reloc_class_plt;
3956    case R_386_COPY:
3957      return reloc_class_copy;
3958    default:
3959      return reloc_class_normal;
3960    }
3961}
3962
3963/* Finish up the dynamic sections.  */
3964
3965static bfd_boolean
3966elf_i386_finish_dynamic_sections (bfd *output_bfd,
3967				  struct bfd_link_info *info)
3968{
3969  struct elf_x86_link_hash_table *htab;
3970
3971  htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
3972  if (htab == NULL)
3973    return FALSE;
3974
3975  if (!htab->elf.dynamic_sections_created)
3976    return TRUE;
3977
3978  if (htab->elf.splt && htab->elf.splt->size > 0)
3979    {
3980      /* UnixWare sets the entsize of .plt to 4, although that doesn't
3981	 really seem like the right value.  */
3982      elf_section_data (htab->elf.splt->output_section)
3983	->this_hdr.sh_entsize = 4;
3984
3985      if (htab->plt.has_plt0)
3986	{
3987	  /* Fill in the special first entry in the procedure linkage
3988	     table.  */
3989	  memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
3990		  htab->lazy_plt->plt0_entry_size);
3991	  memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
3992		  htab->plt0_pad_byte,
3993		  htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
3994	  if (!bfd_link_pic (info))
3995	    {
3996	      bfd_put_32 (output_bfd,
3997			  (htab->elf.sgotplt->output_section->vma
3998			   + htab->elf.sgotplt->output_offset
3999			   + 4),
4000			  htab->elf.splt->contents
4001			  + htab->lazy_plt->plt0_got1_offset);
4002	      bfd_put_32 (output_bfd,
4003			  (htab->elf.sgotplt->output_section->vma
4004			   + htab->elf.sgotplt->output_offset
4005			   + 8),
4006			  htab->elf.splt->contents
4007			  + htab->lazy_plt->plt0_got2_offset);
4008
4009	      if (htab->elf.target_os == is_vxworks)
4010		{
4011		  Elf_Internal_Rela rel;
4012		  int num_plts = (htab->elf.splt->size
4013				  / htab->plt.plt_entry_size) - 1;
4014		  unsigned char *p;
4015		  asection *srelplt2 = htab->srelplt2;
4016
4017		  /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4018		     + 4.  On IA32 we use REL relocations so the
4019		     addend goes in the PLT directly.  */
4020		  rel.r_offset = (htab->elf.splt->output_section->vma
4021				  + htab->elf.splt->output_offset
4022				  + htab->lazy_plt->plt0_got1_offset);
4023		  rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4024					     R_386_32);
4025		  bfd_elf32_swap_reloc_out (output_bfd, &rel,
4026					    srelplt2->contents);
4027		  /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4028		     + 8.  */
4029		  rel.r_offset = (htab->elf.splt->output_section->vma
4030				  + htab->elf.splt->output_offset
4031				  + htab->lazy_plt->plt0_got2_offset);
4032		  rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4033					     R_386_32);
4034		  bfd_elf32_swap_reloc_out (output_bfd, &rel,
4035					    srelplt2->contents +
4036					    sizeof (Elf32_External_Rel));
4037		  /* Correct the .rel.plt.unloaded relocations.  */
4038		  p = srelplt2->contents;
4039		  if (bfd_link_pic (info))
4040		    p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4041		  else
4042		    p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4043
4044		  for (; num_plts; num_plts--)
4045		    {
4046		      bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4047		      rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4048						 R_386_32);
4049		      bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4050		      p += sizeof (Elf32_External_Rel);
4051
4052		      bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4053		      rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
4054						 R_386_32);
4055		      bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4056		      p += sizeof (Elf32_External_Rel);
4057		    }
4058		}
4059	    }
4060	}
4061    }
4062
4063  /* Fill PLT entries for undefined weak symbols in PIE.  */
4064  if (bfd_link_pie (info))
4065    bfd_hash_traverse (&info->hash->table,
4066		       elf_i386_pie_finish_undefweak_symbol,
4067		       info);
4068
4069  return TRUE;
4070}
4071
4072/* Fill PLT/GOT entries and allocate dynamic relocations for local
4073   STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4074   It has to be done before elf_link_sort_relocs is called so that
4075   dynamic relocations are properly sorted.  */
4076
4077static bfd_boolean
4078elf_i386_output_arch_local_syms
4079  (bfd *output_bfd ATTRIBUTE_UNUSED,
4080   struct bfd_link_info *info,
4081   void *flaginfo ATTRIBUTE_UNUSED,
4082   int (*func) (void *, const char *,
4083		Elf_Internal_Sym *,
4084		asection *,
4085		struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4086{
4087  struct elf_x86_link_hash_table *htab
4088    = elf_x86_hash_table (info, I386_ELF_DATA);
4089  if (htab == NULL)
4090    return FALSE;
4091
4092  /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4093  htab_traverse (htab->loc_hash_table,
4094		 elf_i386_finish_local_dynamic_symbol,
4095		 info);
4096
4097  return TRUE;
4098}
4099
4100/* Similar to _bfd_elf_get_synthetic_symtab.  Support PLTs with all
4101   dynamic relocations.   */
4102
4103static long
4104elf_i386_get_synthetic_symtab (bfd *abfd,
4105			       long symcount ATTRIBUTE_UNUSED,
4106			       asymbol **syms ATTRIBUTE_UNUSED,
4107			       long dynsymcount,
4108			       asymbol **dynsyms,
4109			       asymbol **ret)
4110{
4111  long count, i, n;
4112  int j;
4113  bfd_byte *plt_contents;
4114  long relsize;
4115  const struct elf_x86_lazy_plt_layout *lazy_plt;
4116  const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4117  const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4118  const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4119  asection *plt;
4120  bfd_vma got_addr;
4121  enum elf_x86_plt_type plt_type;
4122  struct elf_x86_plt plts[] =
4123    {
4124      { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4125      { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4126      { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4127      { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4128    };
4129
4130  *ret = NULL;
4131
4132  if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4133    return 0;
4134
4135  if (dynsymcount <= 0)
4136    return 0;
4137
4138  relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4139  if (relsize <= 0)
4140    return -1;
4141
4142  non_lazy_plt = NULL;
4143  /* Silence GCC 6.  */
4144  lazy_plt = NULL;
4145  non_lazy_ibt_plt = NULL;
4146  lazy_ibt_plt = NULL;
4147  switch (get_elf_backend_data (abfd)->target_os)
4148    {
4149    case is_normal:
4150    case is_solaris:
4151      non_lazy_plt = &elf_i386_non_lazy_plt;
4152      lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4153      non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4154      /* Fall through */
4155    case is_vxworks:
4156      lazy_plt = &elf_i386_lazy_plt;
4157      break;
4158    default:
4159      abort ();
4160    }
4161
4162  got_addr = 0;
4163
4164  count = 0;
4165  for (j = 0; plts[j].name != NULL; j++)
4166    {
4167      plt = bfd_get_section_by_name (abfd, plts[j].name);
4168      if (plt == NULL || plt->size == 0)
4169	continue;
4170
4171      /* Get the PLT section contents.  */
4172      plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4173      if (plt_contents == NULL)
4174	break;
4175      if (!bfd_get_section_contents (abfd, (asection *) plt,
4176				     plt_contents, 0, plt->size))
4177	{
4178	  free (plt_contents);
4179	  break;
4180	}
4181
4182      /* Check what kind of PLT it is.  */
4183      plt_type = plt_unknown;
4184      if (plts[j].type == plt_unknown
4185	  && (plt->size >= (lazy_plt->plt0_entry_size
4186			    + lazy_plt->plt_entry_size)))
4187	{
4188	  /* Match lazy PLT first.  */
4189	  if (memcmp (plt_contents, lazy_plt->plt0_entry,
4190		      lazy_plt->plt0_got1_offset) == 0)
4191	    {
4192	      /* The fist entry in the lazy IBT PLT is the same as the
4193		 normal lazy PLT.  */
4194	      if (lazy_ibt_plt != NULL
4195		  && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4196			      lazy_ibt_plt->plt_entry,
4197			      lazy_ibt_plt->plt_got_offset) == 0))
4198		plt_type = plt_lazy | plt_second;
4199	      else
4200		plt_type = plt_lazy;
4201	    }
4202	  else if (memcmp (plt_contents, lazy_plt->pic_plt0_entry,
4203			   lazy_plt->plt0_got1_offset) == 0)
4204	    {
4205	      /* The fist entry in the PIC lazy IBT PLT is the same as
4206		 the normal PIC lazy PLT.  */
4207	      if (lazy_ibt_plt != NULL
4208		  && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4209			      lazy_ibt_plt->pic_plt_entry,
4210			      lazy_ibt_plt->plt_got_offset) == 0))
4211		plt_type = plt_lazy | plt_pic | plt_second;
4212	      else
4213		plt_type = plt_lazy | plt_pic;
4214	    }
4215	}
4216
4217      if (non_lazy_plt != NULL
4218	  && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4219	  && plt->size >= non_lazy_plt->plt_entry_size)
4220	{
4221	  /* Match non-lazy PLT.  */
4222	  if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4223		      non_lazy_plt->plt_got_offset) == 0)
4224	    plt_type = plt_non_lazy;
4225	  else if (memcmp (plt_contents, non_lazy_plt->pic_plt_entry,
4226			   non_lazy_plt->plt_got_offset) == 0)
4227	    plt_type = plt_pic;
4228	}
4229
4230      if ((non_lazy_ibt_plt != NULL)
4231	  && (plt_type == plt_unknown || plt_type == plt_second)
4232	  && plt->size >= non_lazy_ibt_plt->plt_entry_size)
4233	{
4234	  if (memcmp (plt_contents,
4235		      non_lazy_ibt_plt->plt_entry,
4236		      non_lazy_ibt_plt->plt_got_offset) == 0)
4237	    {
4238	      /* Match IBT PLT.  */
4239	      plt_type = plt_second;
4240	      non_lazy_plt = non_lazy_ibt_plt;
4241	    }
4242	  else if (memcmp (plt_contents,
4243			   non_lazy_ibt_plt->pic_plt_entry,
4244			   non_lazy_ibt_plt->plt_got_offset) == 0)
4245	    {
4246	      /* Match PIC IBT PLT.  */
4247	      plt_type = plt_second | plt_pic;
4248	      non_lazy_plt = non_lazy_ibt_plt;
4249	    }
4250	}
4251
4252      if (plt_type == plt_unknown)
4253	{
4254	  free (plt_contents);
4255	  continue;
4256	}
4257
4258      plts[j].sec = plt;
4259      plts[j].type = plt_type;
4260
4261      if ((plt_type & plt_lazy))
4262	{
4263	  plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4264	  plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4265	  /* Skip PLT0 in lazy PLT.  */
4266	  i = 1;
4267	}
4268      else
4269	{
4270	  plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4271	  plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4272	  i = 0;
4273	}
4274
4275      /* Skip lazy PLT when the second PLT is used.  */
4276      if ((plt_type & (plt_lazy | plt_second))
4277	  == (plt_lazy | plt_second))
4278	plts[j].count = 0;
4279      else
4280	{
4281	  n = plt->size / plts[j].plt_entry_size;
4282	  plts[j].count = n;
4283	  count += n - i;
4284	}
4285
4286      plts[j].contents = plt_contents;
4287
4288      /* The _GLOBAL_OFFSET_TABLE_ address is needed.  */
4289      if ((plt_type & plt_pic))
4290	got_addr = (bfd_vma) -1;
4291    }
4292
4293  return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4294					    got_addr, plts, dynsyms,
4295					    ret);
4296}
4297
4298/* Set up i386 GNU properties.  Return the first relocatable ELF input
4299   with GNU properties if found.  Otherwise, return NULL.  */
4300
4301static bfd *
4302elf_i386_link_setup_gnu_properties (struct bfd_link_info *info)
4303{
4304  struct elf_x86_init_table init_table;
4305
4306  switch (get_elf_backend_data (info->output_bfd)->target_os)
4307    {
4308    case is_normal:
4309    case is_solaris:
4310      init_table.plt0_pad_byte = 0x0;
4311      init_table.lazy_plt = &elf_i386_lazy_plt;
4312      init_table.non_lazy_plt = &elf_i386_non_lazy_plt;
4313      init_table.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4314      init_table.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4315      break;
4316    case is_vxworks:
4317      init_table.plt0_pad_byte = 0x90;
4318      init_table.lazy_plt = &elf_i386_lazy_plt;
4319      init_table.non_lazy_plt = NULL;
4320      init_table.lazy_ibt_plt = NULL;
4321      init_table.non_lazy_ibt_plt = NULL;
4322      break;
4323    default:
4324      abort ();
4325    }
4326
4327  init_table.r_info = elf32_r_info;
4328  init_table.r_sym = elf32_r_sym;
4329
4330  return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4331}
4332
4333#define TARGET_LITTLE_SYM		i386_elf32_vec
4334#define TARGET_LITTLE_NAME		"elf32-i386"
4335#define ELF_ARCH			bfd_arch_i386
4336#define ELF_TARGET_ID			I386_ELF_DATA
4337#define ELF_MACHINE_CODE		EM_386
4338#define ELF_MAXPAGESIZE			0x1000
4339
4340#define elf_backend_can_gc_sections	1
4341#define elf_backend_can_refcount	1
4342#define elf_backend_want_got_plt	1
4343#define elf_backend_plt_readonly	1
4344#define elf_backend_want_plt_sym	0
4345#define elf_backend_got_header_size	12
4346#define elf_backend_plt_alignment	4
4347#define elf_backend_dtrel_excludes_plt	1
4348#define elf_backend_extern_protected_data 1
4349#define elf_backend_caches_rawsize	1
4350#define elf_backend_want_dynrelro	1
4351
4352/* Support RELA for objdump of prelink objects.  */
4353#define elf_info_to_howto		      elf_i386_info_to_howto_rel
4354#define elf_info_to_howto_rel		      elf_i386_info_to_howto_rel
4355
4356#define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
4357#define bfd_elf32_bfd_reloc_type_lookup	      elf_i386_reloc_type_lookup
4358#define bfd_elf32_bfd_reloc_name_lookup	      elf_i386_reloc_name_lookup
4359#define bfd_elf32_get_synthetic_symtab	      elf_i386_get_synthetic_symtab
4360
4361#define elf_backend_relocs_compatible	      _bfd_elf_relocs_compatible
4362#define elf_backend_check_relocs	      elf_i386_check_relocs
4363#define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
4364#define elf_backend_fake_sections	      elf_i386_fake_sections
4365#define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
4366#define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
4367#define elf_backend_output_arch_local_syms     elf_i386_output_arch_local_syms
4368#define elf_backend_grok_prstatus	      elf_i386_grok_prstatus
4369#define elf_backend_grok_psinfo		      elf_i386_grok_psinfo
4370#define elf_backend_reloc_type_class	      elf_i386_reloc_type_class
4371#define elf_backend_relocate_section	      elf_i386_relocate_section
4372#define elf_backend_setup_gnu_properties      elf_i386_link_setup_gnu_properties
4373#define elf_backend_hide_symbol		      _bfd_x86_elf_hide_symbol
4374
4375#define elf_backend_linux_prpsinfo32_ugid16	TRUE
4376
4377#define	elf32_bed			      elf32_i386_bed
4378
4379#include "elf32-target.h"
4380
4381/* FreeBSD support.  */
4382
4383#undef	TARGET_LITTLE_SYM
4384#define	TARGET_LITTLE_SYM		i386_elf32_fbsd_vec
4385#undef	TARGET_LITTLE_NAME
4386#define	TARGET_LITTLE_NAME		"elf32-i386-freebsd"
4387#undef	ELF_OSABI
4388#define	ELF_OSABI			ELFOSABI_FREEBSD
4389
4390/* The kernel recognizes executables as valid only if they carry a
4391   "FreeBSD" label in the ELF header.  So we put this label on all
4392   executables and (for simplicity) also all other object files.  */
4393
4394static bfd_boolean
4395elf_i386_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
4396{
4397  if (!_bfd_elf_init_file_header (abfd, info))
4398    return FALSE;
4399
4400#ifdef OLD_FREEBSD_ABI_LABEL
4401  {
4402    /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
4403    Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4404    memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
4405  }
4406#endif
4407  return TRUE;
4408}
4409
4410#undef	elf_backend_init_file_header
4411#define	elf_backend_init_file_header	elf_i386_fbsd_init_file_header
4412#undef	elf32_bed
4413#define	elf32_bed				elf32_i386_fbsd_bed
4414
4415#undef elf_backend_add_symbol_hook
4416
4417#include "elf32-target.h"
4418
4419#undef elf_backend_init_file_header
4420
4421/* Solaris 2.  */
4422
4423#undef	TARGET_LITTLE_SYM
4424#define	TARGET_LITTLE_SYM		i386_elf32_sol2_vec
4425#undef	TARGET_LITTLE_NAME
4426#define	TARGET_LITTLE_NAME		"elf32-i386-sol2"
4427
4428#undef	ELF_TARGET_OS
4429#define	ELF_TARGET_OS			is_solaris
4430
4431/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4432   objects won't be recognized.  */
4433#undef ELF_OSABI
4434
4435#undef	elf32_bed
4436#define	elf32_bed			elf32_i386_sol2_bed
4437
4438/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
4439   boundary.  */
4440#undef  elf_backend_static_tls_alignment
4441#define elf_backend_static_tls_alignment 8
4442
4443/* The Solaris 2 ABI requires a plt symbol on all platforms.
4444
4445   Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4446   File, p.63.  */
4447#undef  elf_backend_want_plt_sym
4448#define elf_backend_want_plt_sym	1
4449
4450#undef  elf_backend_strtab_flags
4451#define elf_backend_strtab_flags	SHF_STRINGS
4452
4453/* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
4454   has a type >= SHT_LOOS.  Returns TRUE if these fields were initialised
4455   FALSE otherwise.  ISECTION is the best guess matching section from the
4456   input bfd IBFD, but it might be NULL.  */
4457
4458static bfd_boolean
4459elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
4460						bfd *obfd ATTRIBUTE_UNUSED,
4461						const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
4462						Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
4463{
4464  /* PR 19938: FIXME: Need to add code for setting the sh_info
4465     and sh_link fields of Solaris specific section types.  */
4466  return FALSE;
4467
4468  /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
4469     Object File Format, Table 13-9  ELF sh_link and sh_info Interpretation:
4470
4471http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
4472
4473     The following values should be set:
4474
4475Type		     Link			    Info
4476-----------------------------------------------------------------------------
4477SHT_SUNW_ancillary   The section header index of    0
4478 [0x6fffffee]	     the associated string table.
4479
4480SHT_SUNW_capinfo     The section header index of    For a dynamic object, the
4481 [0x6ffffff0]	     the associated symbol table.   section header index of
4482						    the associated
4483						    SHT_SUNW_capchain table,
4484						    otherwise 0.
4485
4486SHT_SUNW_symsort     The section header index of    0
4487 [0x6ffffff1]	     the associated symbol table.
4488
4489SHT_SUNW_tlssort     The section header index of    0
4490 [0x6ffffff2]	     the associated symbol table.
4491
4492SHT_SUNW_LDYNSYM     The section header index of    One greater than the
4493 [0x6ffffff3]	     the associated string table.   symbol table index of the
4494		     This index is the same string  last local symbol,
4495		     table used by the SHT_DYNSYM   STB_LOCAL. Since
4496		     section.			    SHT_SUNW_LDYNSYM only
4497						    contains local symbols,
4498						    sh_info is equivalent to
4499						    the number of symbols in
4500						    the table.
4501
4502SHT_SUNW_cap	     If symbol capabilities exist,  If any capabilities refer
4503 [0x6ffffff5]	     the section header index of    to named strings, the
4504		     the associated		    section header index of
4505		     SHT_SUNW_capinfo table,	    the associated string
4506			  otherwise 0.		    table, otherwise 0.
4507
4508SHT_SUNW_move	     The section header index of    0
4509 [0x6ffffffa]	     the associated symbol table.
4510
4511SHT_SUNW_COMDAT	     0				    0
4512 [0x6ffffffb]
4513
4514SHT_SUNW_syminfo     The section header index of    The section header index
4515 [0x6ffffffc]	     the associated symbol table.   of the associated
4516						    .dynamic section.
4517
4518SHT_SUNW_verdef	     The section header index of    The number of version
4519 [0x6ffffffd]	     the associated string table.   definitions within the
4520						    section.
4521
4522SHT_SUNW_verneed     The section header index of    The number of version
4523 [0x6ffffffe]	     the associated string table.   dependencies within the
4524						    section.
4525
4526SHT_SUNW_versym	     The section header index of    0
4527 [0x6fffffff]	     the associated symbol table.  */
4528}
4529
4530#undef  elf_backend_copy_special_section_fields
4531#define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
4532
4533#include "elf32-target.h"
4534
4535/* Intel MCU support.  */
4536
4537static bfd_boolean
4538elf32_iamcu_elf_object_p (bfd *abfd)
4539{
4540  /* Set the right machine number for an IAMCU elf32 file.  */
4541  bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
4542  return TRUE;
4543}
4544
4545#undef  TARGET_LITTLE_SYM
4546#define TARGET_LITTLE_SYM		iamcu_elf32_vec
4547#undef  TARGET_LITTLE_NAME
4548#define TARGET_LITTLE_NAME		"elf32-iamcu"
4549#undef  ELF_ARCH
4550#define ELF_ARCH			bfd_arch_iamcu
4551
4552#undef	ELF_MACHINE_CODE
4553#define	ELF_MACHINE_CODE		EM_IAMCU
4554
4555#undef	ELF_TARGET_OS
4556#undef	ELF_OSABI
4557
4558#undef  elf32_bed
4559#define elf32_bed			elf32_iamcu_bed
4560
4561#undef	elf_backend_object_p
4562#define elf_backend_object_p		elf32_iamcu_elf_object_p
4563
4564#undef	elf_backend_static_tls_alignment
4565
4566#undef	elf_backend_want_plt_sym
4567#define elf_backend_want_plt_sym	0
4568
4569#undef  elf_backend_strtab_flags
4570#undef  elf_backend_copy_special_section_fields
4571
4572#include "elf32-target.h"
4573
4574/* Restore defaults.  */
4575#undef	ELF_ARCH
4576#define ELF_ARCH			bfd_arch_i386
4577#undef	ELF_MACHINE_CODE
4578#define ELF_MACHINE_CODE		EM_386
4579#undef	elf_backend_object_p
4580
4581/* VxWorks support.  */
4582
4583#undef	TARGET_LITTLE_SYM
4584#define TARGET_LITTLE_SYM		i386_elf32_vxworks_vec
4585#undef	TARGET_LITTLE_NAME
4586#define TARGET_LITTLE_NAME		"elf32-i386-vxworks"
4587#undef	ELF_OSABI
4588#undef	ELF_MAXPAGESIZE
4589#define ELF_MAXPAGESIZE			0x1000
4590#undef	elf_backend_plt_alignment
4591#define elf_backend_plt_alignment	4
4592
4593#undef	ELF_TARGET_OS
4594#define ELF_TARGET_OS		is_vxworks
4595
4596#undef elf_backend_relocs_compatible
4597#undef elf_backend_add_symbol_hook
4598#define elf_backend_add_symbol_hook \
4599  elf_vxworks_add_symbol_hook
4600#undef elf_backend_link_output_symbol_hook
4601#define elf_backend_link_output_symbol_hook \
4602  elf_vxworks_link_output_symbol_hook
4603#undef elf_backend_emit_relocs
4604#define elf_backend_emit_relocs			elf_vxworks_emit_relocs
4605#undef elf_backend_final_write_processing
4606#define elf_backend_final_write_processing \
4607  elf_vxworks_final_write_processing
4608#undef elf_backend_static_tls_alignment
4609
4610/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4611   define it.  */
4612#undef elf_backend_want_plt_sym
4613#define elf_backend_want_plt_sym	1
4614
4615#undef	elf32_bed
4616#define elf32_bed				elf32_i386_vxworks_bed
4617
4618#include "elf32-target.h"
4619