Merge branch 'vendor/GDB'
[dragonfly.git] / contrib / gdb-7 / bfd / elf32-i386.c
1 /* Intel 80386/80486-specific support for 32-bit ELF
2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5
6    This file is part of BFD, the Binary File Descriptor library.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf-vxworks.h"
29 #include "bfd_stdint.h"
30 #include "objalloc.h"
31 #include "hashtab.h"
32 #include "dwarf2.h"
33
34 /* 386 uses REL relocations instead of RELA.  */
35 #define USE_REL 1
36
37 #include "elf/i386.h"
38
39 static reloc_howto_type elf_howto_table[]=
40 {
41   HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
42         bfd_elf_generic_reloc, "R_386_NONE",
43         TRUE, 0x00000000, 0x00000000, FALSE),
44   HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
45         bfd_elf_generic_reloc, "R_386_32",
46         TRUE, 0xffffffff, 0xffffffff, FALSE),
47   HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
48         bfd_elf_generic_reloc, "R_386_PC32",
49         TRUE, 0xffffffff, 0xffffffff, TRUE),
50   HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
51         bfd_elf_generic_reloc, "R_386_GOT32",
52         TRUE, 0xffffffff, 0xffffffff, FALSE),
53   HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
54         bfd_elf_generic_reloc, "R_386_PLT32",
55         TRUE, 0xffffffff, 0xffffffff, TRUE),
56   HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
57         bfd_elf_generic_reloc, "R_386_COPY",
58         TRUE, 0xffffffff, 0xffffffff, FALSE),
59   HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
60         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
61         TRUE, 0xffffffff, 0xffffffff, FALSE),
62   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
63         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
64         TRUE, 0xffffffff, 0xffffffff, FALSE),
65   HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
66         bfd_elf_generic_reloc, "R_386_RELATIVE",
67         TRUE, 0xffffffff, 0xffffffff, FALSE),
68   HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
69         bfd_elf_generic_reloc, "R_386_GOTOFF",
70         TRUE, 0xffffffff, 0xffffffff, FALSE),
71   HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
72         bfd_elf_generic_reloc, "R_386_GOTPC",
73         TRUE, 0xffffffff, 0xffffffff, TRUE),
74
75   /* We have a gap in the reloc numbers here.
76      R_386_standard counts the number up to this point, and
77      R_386_ext_offset is the value to subtract from a reloc type of
78      R_386_16 thru R_386_PC8 to form an index into this table.  */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
81
82   /* These relocs are a GNU extension.  */
83   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
84         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
85         TRUE, 0xffffffff, 0xffffffff, FALSE),
86   HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
87         bfd_elf_generic_reloc, "R_386_TLS_IE",
88         TRUE, 0xffffffff, 0xffffffff, FALSE),
89   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
90         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
91         TRUE, 0xffffffff, 0xffffffff, FALSE),
92   HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
93         bfd_elf_generic_reloc, "R_386_TLS_LE",
94         TRUE, 0xffffffff, 0xffffffff, FALSE),
95   HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
96         bfd_elf_generic_reloc, "R_386_TLS_GD",
97         TRUE, 0xffffffff, 0xffffffff, FALSE),
98   HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
99         bfd_elf_generic_reloc, "R_386_TLS_LDM",
100         TRUE, 0xffffffff, 0xffffffff, FALSE),
101   HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
102         bfd_elf_generic_reloc, "R_386_16",
103         TRUE, 0xffff, 0xffff, FALSE),
104   HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
105         bfd_elf_generic_reloc, "R_386_PC16",
106         TRUE, 0xffff, 0xffff, TRUE),
107   HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
108         bfd_elf_generic_reloc, "R_386_8",
109         TRUE, 0xff, 0xff, FALSE),
110   HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
111         bfd_elf_generic_reloc, "R_386_PC8",
112         TRUE, 0xff, 0xff, TRUE),
113
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116   /* These are common with Solaris TLS implementation.  */
117   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
118         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
119         TRUE, 0xffffffff, 0xffffffff, FALSE),
120   HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
121         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
122         TRUE, 0xffffffff, 0xffffffff, FALSE),
123   HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
124         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
125         TRUE, 0xffffffff, 0xffffffff, FALSE),
126   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
128         TRUE, 0xffffffff, 0xffffffff, FALSE),
129   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
130         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
131         TRUE, 0xffffffff, 0xffffffff, FALSE),
132   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
133         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
134         TRUE, 0xffffffff, 0xffffffff, FALSE),
135   EMPTY_HOWTO (38),
136   HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
137         bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
138         TRUE, 0xffffffff, 0xffffffff, FALSE),
139   HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
140         bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
141         FALSE, 0, 0, FALSE),
142   HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
143         bfd_elf_generic_reloc, "R_386_TLS_DESC",
144         TRUE, 0xffffffff, 0xffffffff, FALSE),
145   HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
146         bfd_elf_generic_reloc, "R_386_IRELATIVE",
147         TRUE, 0xffffffff, 0xffffffff, FALSE),
148
149   /* Another gap.  */
150 #define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
151 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
152
153 /* GNU extension to record C++ vtable hierarchy.  */
154   HOWTO (R_386_GNU_VTINHERIT,   /* type */
155          0,                     /* rightshift */
156          2,                     /* size (0 = byte, 1 = short, 2 = long) */
157          0,                     /* bitsize */
158          FALSE,                 /* pc_relative */
159          0,                     /* bitpos */
160          complain_overflow_dont, /* complain_on_overflow */
161          NULL,                  /* special_function */
162          "R_386_GNU_VTINHERIT", /* name */
163          FALSE,                 /* partial_inplace */
164          0,                     /* src_mask */
165          0,                     /* dst_mask */
166          FALSE),                /* pcrel_offset */
167
168 /* GNU extension to record C++ vtable member usage.  */
169   HOWTO (R_386_GNU_VTENTRY,     /* type */
170          0,                     /* rightshift */
171          2,                     /* size (0 = byte, 1 = short, 2 = long) */
172          0,                     /* bitsize */
173          FALSE,                 /* pc_relative */
174          0,                     /* bitpos */
175          complain_overflow_dont, /* complain_on_overflow */
176          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
177          "R_386_GNU_VTENTRY",   /* name */
178          FALSE,                 /* partial_inplace */
179          0,                     /* src_mask */
180          0,                     /* dst_mask */
181          FALSE)                 /* pcrel_offset */
182
183 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
184
185 };
186
187 #ifdef DEBUG_GEN_RELOC
188 #define TRACE(str) \
189   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
190 #else
191 #define TRACE(str)
192 #endif
193
194 static reloc_howto_type *
195 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
196                             bfd_reloc_code_real_type code)
197 {
198   switch (code)
199     {
200     case BFD_RELOC_NONE:
201       TRACE ("BFD_RELOC_NONE");
202       return &elf_howto_table[R_386_NONE];
203
204     case BFD_RELOC_32:
205       TRACE ("BFD_RELOC_32");
206       return &elf_howto_table[R_386_32];
207
208     case BFD_RELOC_CTOR:
209       TRACE ("BFD_RELOC_CTOR");
210       return &elf_howto_table[R_386_32];
211
212     case BFD_RELOC_32_PCREL:
213       TRACE ("BFD_RELOC_PC32");
214       return &elf_howto_table[R_386_PC32];
215
216     case BFD_RELOC_386_GOT32:
217       TRACE ("BFD_RELOC_386_GOT32");
218       return &elf_howto_table[R_386_GOT32];
219
220     case BFD_RELOC_386_PLT32:
221       TRACE ("BFD_RELOC_386_PLT32");
222       return &elf_howto_table[R_386_PLT32];
223
224     case BFD_RELOC_386_COPY:
225       TRACE ("BFD_RELOC_386_COPY");
226       return &elf_howto_table[R_386_COPY];
227
228     case BFD_RELOC_386_GLOB_DAT:
229       TRACE ("BFD_RELOC_386_GLOB_DAT");
230       return &elf_howto_table[R_386_GLOB_DAT];
231
232     case BFD_RELOC_386_JUMP_SLOT:
233       TRACE ("BFD_RELOC_386_JUMP_SLOT");
234       return &elf_howto_table[R_386_JUMP_SLOT];
235
236     case BFD_RELOC_386_RELATIVE:
237       TRACE ("BFD_RELOC_386_RELATIVE");
238       return &elf_howto_table[R_386_RELATIVE];
239
240     case BFD_RELOC_386_GOTOFF:
241       TRACE ("BFD_RELOC_386_GOTOFF");
242       return &elf_howto_table[R_386_GOTOFF];
243
244     case BFD_RELOC_386_GOTPC:
245       TRACE ("BFD_RELOC_386_GOTPC");
246       return &elf_howto_table[R_386_GOTPC];
247
248       /* These relocs are a GNU extension.  */
249     case BFD_RELOC_386_TLS_TPOFF:
250       TRACE ("BFD_RELOC_386_TLS_TPOFF");
251       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
252
253     case BFD_RELOC_386_TLS_IE:
254       TRACE ("BFD_RELOC_386_TLS_IE");
255       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
256
257     case BFD_RELOC_386_TLS_GOTIE:
258       TRACE ("BFD_RELOC_386_TLS_GOTIE");
259       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
260
261     case BFD_RELOC_386_TLS_LE:
262       TRACE ("BFD_RELOC_386_TLS_LE");
263       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
264
265     case BFD_RELOC_386_TLS_GD:
266       TRACE ("BFD_RELOC_386_TLS_GD");
267       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
268
269     case BFD_RELOC_386_TLS_LDM:
270       TRACE ("BFD_RELOC_386_TLS_LDM");
271       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
272
273     case BFD_RELOC_16:
274       TRACE ("BFD_RELOC_16");
275       return &elf_howto_table[R_386_16 - R_386_ext_offset];
276
277     case BFD_RELOC_16_PCREL:
278       TRACE ("BFD_RELOC_16_PCREL");
279       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
280
281     case BFD_RELOC_8:
282       TRACE ("BFD_RELOC_8");
283       return &elf_howto_table[R_386_8 - R_386_ext_offset];
284
285     case BFD_RELOC_8_PCREL:
286       TRACE ("BFD_RELOC_8_PCREL");
287       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
288
289     /* Common with Sun TLS implementation.  */
290     case BFD_RELOC_386_TLS_LDO_32:
291       TRACE ("BFD_RELOC_386_TLS_LDO_32");
292       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
293
294     case BFD_RELOC_386_TLS_IE_32:
295       TRACE ("BFD_RELOC_386_TLS_IE_32");
296       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
297
298     case BFD_RELOC_386_TLS_LE_32:
299       TRACE ("BFD_RELOC_386_TLS_LE_32");
300       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
301
302     case BFD_RELOC_386_TLS_DTPMOD32:
303       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
304       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
305
306     case BFD_RELOC_386_TLS_DTPOFF32:
307       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
308       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
309
310     case BFD_RELOC_386_TLS_TPOFF32:
311       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
312       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
313
314     case BFD_RELOC_386_TLS_GOTDESC:
315       TRACE ("BFD_RELOC_386_TLS_GOTDESC");
316       return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
317
318     case BFD_RELOC_386_TLS_DESC_CALL:
319       TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
320       return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
321
322     case BFD_RELOC_386_TLS_DESC:
323       TRACE ("BFD_RELOC_386_TLS_DESC");
324       return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
325
326     case BFD_RELOC_386_IRELATIVE:
327       TRACE ("BFD_RELOC_386_IRELATIVE");
328       return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
329
330     case BFD_RELOC_VTABLE_INHERIT:
331       TRACE ("BFD_RELOC_VTABLE_INHERIT");
332       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
333
334     case BFD_RELOC_VTABLE_ENTRY:
335       TRACE ("BFD_RELOC_VTABLE_ENTRY");
336       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
337
338     default:
339       break;
340     }
341
342   TRACE ("Unknown");
343   return 0;
344 }
345
346 static reloc_howto_type *
347 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
348                             const char *r_name)
349 {
350   unsigned int i;
351
352   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
353     if (elf_howto_table[i].name != NULL
354         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
355       return &elf_howto_table[i];
356
357   return NULL;
358 }
359
360 static reloc_howto_type *
361 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
362 {
363   unsigned int indx;
364
365   if ((indx = r_type) >= R_386_standard
366       && ((indx = r_type - R_386_ext_offset) - R_386_standard
367           >= R_386_ext - R_386_standard)
368       && ((indx = r_type - R_386_tls_offset) - R_386_ext
369           >= R_386_irelative - R_386_ext)
370       && ((indx = r_type - R_386_vt_offset) - R_386_irelative
371           >= R_386_vt - R_386_irelative))
372     {
373       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
374                              abfd, (int) r_type);
375       indx = R_386_NONE;
376     }
377   BFD_ASSERT (elf_howto_table [indx].type == r_type);
378   return &elf_howto_table[indx];
379 }
380
381 static void
382 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
383                             arelent *cache_ptr,
384                             Elf_Internal_Rela *dst)
385 {
386   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
387   cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
388 }
389
390 /* Return whether a symbol name implies a local label.  The UnixWare
391    2.1 cc generates temporary symbols that start with .X, so we
392    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
393    If so, we should move the .X recognition into
394    _bfd_elf_is_local_label_name.  */
395
396 static bfd_boolean
397 elf_i386_is_local_label_name (bfd *abfd, const char *name)
398 {
399   if (name[0] == '.' && name[1] == 'X')
400     return TRUE;
401
402   return _bfd_elf_is_local_label_name (abfd, name);
403 }
404 \f
405 /* Support for core dump NOTE sections.  */
406
407 static bfd_boolean
408 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
409 {
410   int offset;
411   size_t size;
412
413   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
414     {
415       int pr_version = bfd_get_32 (abfd, note->descdata);
416
417       if (pr_version != 1)
418         return FALSE;
419
420       /* pr_cursig */
421       elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
422
423       /* pr_pid */
424       elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
425
426       /* pr_reg */
427       offset = 28;
428       size = bfd_get_32 (abfd, note->descdata + 8);
429     }
430   else
431     {
432       switch (note->descsz)
433         {
434         default:
435           return FALSE;
436
437         case 144:               /* Linux/i386 */
438           /* pr_cursig */
439           elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
440
441           /* pr_pid */
442           elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
443
444           /* pr_reg */
445           offset = 72;
446           size = 68;
447
448           break;
449         }
450     }
451
452   /* Make a ".reg/999" section.  */
453   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
454                                           size, note->descpos + offset);
455 }
456
457 static bfd_boolean
458 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
459 {
460   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
461     {
462       int pr_version = bfd_get_32 (abfd, note->descdata);
463
464       if (pr_version != 1)
465         return FALSE;
466
467       elf_tdata (abfd)->core_program
468         = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
469       elf_tdata (abfd)->core_command
470         = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
471     }
472   else
473     {
474       switch (note->descsz)
475         {
476         default:
477           return FALSE;
478
479         case 124:               /* Linux/i386 elf_prpsinfo.  */
480           elf_tdata (abfd)->core_pid
481             = bfd_get_32 (abfd, note->descdata + 12);
482           elf_tdata (abfd)->core_program
483             = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
484           elf_tdata (abfd)->core_command
485             = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
486         }
487     }
488
489   /* Note that for some reason, a spurious space is tacked
490      onto the end of the args in some (at least one anyway)
491      implementations, so strip it off if it exists.  */
492   {
493     char *command = elf_tdata (abfd)->core_command;
494     int n = strlen (command);
495
496     if (0 < n && command[n - 1] == ' ')
497       command[n - 1] = '\0';
498   }
499
500   return TRUE;
501 }
502 \f
503 /* Functions for the i386 ELF linker.
504
505    In order to gain some understanding of code in this file without
506    knowing all the intricate details of the linker, note the
507    following:
508
509    Functions named elf_i386_* are called by external routines, other
510    functions are only called locally.  elf_i386_* functions appear
511    in this file more or less in the order in which they are called
512    from external routines.  eg. elf_i386_check_relocs is called
513    early in the link process, elf_i386_finish_dynamic_sections is
514    one of the last functions.  */
515
516
517 /* The name of the dynamic interpreter.  This is put in the .interp
518    section.  */
519
520 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
521
522 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
523    copying dynamic variables from a shared lib into an app's dynbss
524    section, and instead use a dynamic relocation to point into the
525    shared lib.  */
526 #define ELIMINATE_COPY_RELOCS 1
527
528 /* The size in bytes of an entry in the procedure linkage table.  */
529
530 #define PLT_ENTRY_SIZE 16
531
532 /* The first entry in an absolute procedure linkage table looks like
533    this.  See the SVR4 ABI i386 supplement to see how this works.
534    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
535
536 static const bfd_byte elf_i386_plt0_entry[12] =
537 {
538   0xff, 0x35,   /* pushl contents of address */
539   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
540   0xff, 0x25,   /* jmp indirect */
541   0, 0, 0, 0    /* replaced with address of .got + 8.  */
542 };
543
544 /* Subsequent entries in an absolute procedure linkage table look like
545    this.  */
546
547 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
548 {
549   0xff, 0x25,   /* jmp indirect */
550   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
551   0x68,         /* pushl immediate */
552   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
553   0xe9,         /* jmp relative */
554   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
555 };
556
557 /* The first entry in a PIC procedure linkage table look like this.
558    Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte.  */
559
560 static const bfd_byte elf_i386_pic_plt0_entry[12] =
561 {
562   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
563   0xff, 0xa3, 8, 0, 0, 0        /* jmp *8(%ebx) */
564 };
565
566 /* Subsequent entries in a PIC procedure linkage table look like this.  */
567
568 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
569 {
570   0xff, 0xa3,   /* jmp *offset(%ebx) */
571   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
572   0x68,         /* pushl immediate */
573   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
574   0xe9,         /* jmp relative */
575   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
576 };
577
578 /* .eh_frame covering the .plt section.  */
579
580 static const bfd_byte elf_i386_eh_frame_plt[] =
581 {
582 #define PLT_CIE_LENGTH          20
583 #define PLT_FDE_LENGTH          36
584 #define PLT_FDE_START_OFFSET    4 + PLT_CIE_LENGTH + 8
585 #define PLT_FDE_LEN_OFFSET      4 + PLT_CIE_LENGTH + 12
586   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
587   0, 0, 0, 0,                   /* CIE ID */
588   1,                            /* CIE version */
589   'z', 'R', 0,                  /* Augmentation string */
590   1,                            /* Code alignment factor */
591   0x7c,                         /* Data alignment factor */
592   8,                            /* Return address column */
593   1,                            /* Augmentation size */
594   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
595   DW_CFA_def_cfa, 4, 4,         /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
596   DW_CFA_offset + 8, 1,         /* DW_CFA_offset: r8 (eip) at cfa-4 */
597   DW_CFA_nop, DW_CFA_nop,
598
599   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
600   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
601   0, 0, 0, 0,                   /* R_386_PC32 .plt goes here */
602   0, 0, 0, 0,                   /* .plt size goes here */
603   0,                            /* Augmentation size */
604   DW_CFA_def_cfa_offset, 8,     /* DW_CFA_def_cfa_offset: 8 */
605   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
606   DW_CFA_def_cfa_offset, 12,    /* DW_CFA_def_cfa_offset: 12 */
607   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
608   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
609   11,                           /* Block length */
610   DW_OP_breg4, 4,               /* DW_OP_breg4 (esp): 4 */
611   DW_OP_breg8, 0,               /* DW_OP_breg8 (eip): 0 */
612   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
613   DW_OP_lit2, DW_OP_shl, DW_OP_plus,
614   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
615 };
616
617 struct elf_i386_plt_layout
618 {
619   /* The first entry in an absolute procedure linkage table looks like this.  */
620   const bfd_byte *plt0_entry;
621   unsigned int plt0_entry_size;
622
623   /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2].  */
624   unsigned int plt0_got1_offset;
625   unsigned int plt0_got2_offset;
626
627   /* Later entries in an absolute procedure linkage table look like this.  */
628   const bfd_byte *plt_entry;
629   unsigned int plt_entry_size;
630
631   /* Offsets into plt_entry that are to be replaced with...  */
632   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
633   unsigned int plt_reloc_offset;  /* ... offset into relocation table. */
634   unsigned int plt_plt_offset;    /* ... offset to start of .plt. */
635
636   /* Offset into plt_entry where the initial value of the GOT entry points.  */
637   unsigned int plt_lazy_offset;
638
639   /* The first entry in a PIC procedure linkage table looks like this.  */
640   const bfd_byte *pic_plt0_entry;
641
642   /* Subsequent entries in a PIC procedure linkage table look like this.  */
643   const bfd_byte *pic_plt_entry;
644
645   /* .eh_frame covering the .plt section.  */
646   const bfd_byte *eh_frame_plt;
647   unsigned int eh_frame_plt_size;
648 };
649
650 #define GET_PLT_ENTRY_SIZE(abfd) \
651   get_elf_i386_backend_data (abfd)->plt->plt_entry_size
652
653 /* These are the standard parameters.  */
654 static const struct elf_i386_plt_layout elf_i386_plt =
655   {
656     elf_i386_plt0_entry,                /* plt0_entry */
657     sizeof (elf_i386_plt0_entry),       /* plt0_entry_size */
658     2,                                  /* plt0_got1_offset */
659     8,                                  /* plt0_got2_offset */
660     elf_i386_plt_entry,                 /* plt_entry */
661     PLT_ENTRY_SIZE,                     /* plt_entry_size */
662     2,                                  /* plt_got_offset */
663     7,                                  /* plt_reloc_offset */
664     12,                                 /* plt_plt_offset */
665     6,                                  /* plt_lazy_offset */
666     elf_i386_pic_plt0_entry,            /* pic_plt0_entry */
667     elf_i386_pic_plt_entry,             /* pic_plt_entry */
668     elf_i386_eh_frame_plt,              /* eh_frame_plt */
669     sizeof (elf_i386_eh_frame_plt),     /* eh_frame_plt_size */
670   };
671 \f
672
673 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
674    for the PLTResolve stub and then for each PLT entry.  */
675 #define PLTRESOLVE_RELOCS_SHLIB 0
676 #define PLTRESOLVE_RELOCS 2
677 #define PLT_NON_JUMP_SLOT_RELOCS 2
678
679 /* Architecture-specific backend data for i386.  */
680
681 struct elf_i386_backend_data
682 {
683   /* Parameters describing PLT generation.  */
684   const struct elf_i386_plt_layout *plt;
685
686   /* Value used to fill the unused bytes of the first PLT entry.  */
687   bfd_byte plt0_pad_byte;
688
689   /* True if the target system is VxWorks.  */
690   int is_vxworks;
691 };
692
693 #define get_elf_i386_backend_data(abfd) \
694   ((const struct elf_i386_backend_data *) \
695    get_elf_backend_data (abfd)->arch_data)
696
697 /* These are the standard parameters.  */
698 static const struct elf_i386_backend_data elf_i386_arch_bed =
699   {
700     &elf_i386_plt,                      /* plt */
701     0,                                  /* plt0_pad_byte */
702     0,                                  /* is_vxworks */
703   };
704
705 #define elf_backend_arch_data   &elf_i386_arch_bed
706
707 /* i386 ELF linker hash entry.  */
708
709 struct elf_i386_link_hash_entry
710 {
711   struct elf_link_hash_entry elf;
712
713   /* Track dynamic relocs copied for this symbol.  */
714   struct elf_dyn_relocs *dyn_relocs;
715
716 #define GOT_UNKNOWN     0
717 #define GOT_NORMAL      1
718 #define GOT_TLS_GD      2
719 #define GOT_TLS_IE      4
720 #define GOT_TLS_IE_POS  5
721 #define GOT_TLS_IE_NEG  6
722 #define GOT_TLS_IE_BOTH 7
723 #define GOT_TLS_GDESC   8
724 #define GOT_TLS_GD_BOTH_P(type)                                         \
725   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
726 #define GOT_TLS_GD_P(type)                                              \
727   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
728 #define GOT_TLS_GDESC_P(type)                                           \
729   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
730 #define GOT_TLS_GD_ANY_P(type)                                          \
731   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
732   unsigned char tls_type;
733
734   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
735      starting at the end of the jump table.  */
736   bfd_vma tlsdesc_got;
737 };
738
739 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
740
741 struct elf_i386_obj_tdata
742 {
743   struct elf_obj_tdata root;
744
745   /* tls_type for each local got entry.  */
746   char *local_got_tls_type;
747
748   /* GOTPLT entries for TLS descriptors.  */
749   bfd_vma *local_tlsdesc_gotent;
750 };
751
752 #define elf_i386_tdata(abfd) \
753   ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
754
755 #define elf_i386_local_got_tls_type(abfd) \
756   (elf_i386_tdata (abfd)->local_got_tls_type)
757
758 #define elf_i386_local_tlsdesc_gotent(abfd) \
759   (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
760
761 #define is_i386_elf(bfd)                                \
762   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
763    && elf_tdata (bfd) != NULL                           \
764    && elf_object_id (bfd) == I386_ELF_DATA)
765
766 static bfd_boolean
767 elf_i386_mkobject (bfd *abfd)
768 {
769   return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
770                                   I386_ELF_DATA);
771 }
772
773 /* i386 ELF linker hash table.  */
774
775 struct elf_i386_link_hash_table
776 {
777   struct elf_link_hash_table elf;
778
779   /* Short-cuts to get to dynamic linker sections.  */
780   asection *sdynbss;
781   asection *srelbss;
782   asection *plt_eh_frame;
783
784   union
785   {
786     bfd_signed_vma refcount;
787     bfd_vma offset;
788   } tls_ldm_got;
789
790   /* The amount of space used by the reserved portion of the sgotplt
791      section, plus whatever space is used by the jump slots.  */
792   bfd_vma sgotplt_jump_table_size;
793
794   /* Small local sym cache.  */
795   struct sym_cache sym_cache;
796
797   /* _TLS_MODULE_BASE_ symbol.  */
798   struct bfd_link_hash_entry *tls_module_base;
799
800   /* Used by local STT_GNU_IFUNC symbols.  */
801   htab_t loc_hash_table;
802   void * loc_hash_memory;
803
804   /* The (unloaded but important) .rel.plt.unloaded section on VxWorks.  */
805   asection *srelplt2;
806
807   /* The index of the next unused R_386_TLS_DESC slot in .rel.plt.  */
808   bfd_vma next_tls_desc_index;
809
810   /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt.  */
811   bfd_vma next_jump_slot_index;
812
813   /* The index of the next unused R_386_IRELATIVE slot in .rel.plt.  */
814   bfd_vma next_irelative_index;
815 };
816
817 /* Get the i386 ELF linker hash table from a link_info structure.  */
818
819 #define elf_i386_hash_table(p) \
820   (elf_hash_table_id  ((struct elf_link_hash_table *) ((p)->hash)) \
821   == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
822
823 #define elf_i386_compute_jump_table_size(htab) \
824   ((htab)->next_tls_desc_index * 4)
825
826 /* Create an entry in an i386 ELF linker hash table.  */
827
828 static struct bfd_hash_entry *
829 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
830                             struct bfd_hash_table *table,
831                             const char *string)
832 {
833   /* Allocate the structure if it has not already been allocated by a
834      subclass.  */
835   if (entry == NULL)
836     {
837       entry = (struct bfd_hash_entry *)
838           bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
839       if (entry == NULL)
840         return entry;
841     }
842
843   /* Call the allocation method of the superclass.  */
844   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
845   if (entry != NULL)
846     {
847       struct elf_i386_link_hash_entry *eh;
848
849       eh = (struct elf_i386_link_hash_entry *) entry;
850       eh->dyn_relocs = NULL;
851       eh->tls_type = GOT_UNKNOWN;
852       eh->tlsdesc_got = (bfd_vma) -1;
853     }
854
855   return entry;
856 }
857
858 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
859   for local symbol so that we can handle local STT_GNU_IFUNC symbols
860   as global symbol.  We reuse indx and dynstr_index for local symbol
861   hash since they aren't used by global symbols in this backend.  */
862
863 static hashval_t
864 elf_i386_local_htab_hash (const void *ptr)
865 {
866   struct elf_link_hash_entry *h
867     = (struct elf_link_hash_entry *) ptr;
868   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
869 }
870
871 /* Compare local hash entries.  */
872
873 static int
874 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
875 {
876   struct elf_link_hash_entry *h1
877      = (struct elf_link_hash_entry *) ptr1;
878   struct elf_link_hash_entry *h2
879     = (struct elf_link_hash_entry *) ptr2;
880
881   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
882 }
883
884 /* Find and/or create a hash entry for local symbol.  */
885
886 static struct elf_link_hash_entry *
887 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
888                              bfd *abfd, const Elf_Internal_Rela *rel,
889                              bfd_boolean create)
890 {
891   struct elf_i386_link_hash_entry e, *ret;
892   asection *sec = abfd->sections;
893   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
894                                        ELF32_R_SYM (rel->r_info));
895   void **slot;
896
897   e.elf.indx = sec->id;
898   e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
899   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
900                                    create ? INSERT : NO_INSERT);
901
902   if (!slot)
903     return NULL;
904
905   if (*slot)
906     {
907       ret = (struct elf_i386_link_hash_entry *) *slot;
908       return &ret->elf;
909     }
910
911   ret = (struct elf_i386_link_hash_entry *)
912         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
913                         sizeof (struct elf_i386_link_hash_entry));
914   if (ret)
915     {
916       memset (ret, 0, sizeof (*ret));
917       ret->elf.indx = sec->id;
918       ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
919       ret->elf.dynindx = -1;
920       *slot = ret;
921     }
922   return &ret->elf;
923 }
924
925 /* Create an i386 ELF linker hash table.  */
926
927 static struct bfd_link_hash_table *
928 elf_i386_link_hash_table_create (bfd *abfd)
929 {
930   struct elf_i386_link_hash_table *ret;
931   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
932
933   ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
934   if (ret == NULL)
935     return NULL;
936
937   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
938                                       elf_i386_link_hash_newfunc,
939                                       sizeof (struct elf_i386_link_hash_entry),
940                                       I386_ELF_DATA))
941     {
942       free (ret);
943       return NULL;
944     }
945
946   ret->sdynbss = NULL;
947   ret->srelbss = NULL;
948   ret->plt_eh_frame = NULL;
949   ret->tls_ldm_got.refcount = 0;
950   ret->next_tls_desc_index = 0;
951   ret->sgotplt_jump_table_size = 0;
952   ret->sym_cache.abfd = NULL;
953   ret->srelplt2 = NULL;
954   ret->tls_module_base = NULL;
955   ret->next_jump_slot_index = 0;
956   ret->next_irelative_index = 0;
957
958   ret->loc_hash_table = htab_try_create (1024,
959                                          elf_i386_local_htab_hash,
960                                          elf_i386_local_htab_eq,
961                                          NULL);
962   ret->loc_hash_memory = objalloc_create ();
963   if (!ret->loc_hash_table || !ret->loc_hash_memory)
964     {
965       free (ret);
966       return NULL;
967     }
968
969   return &ret->elf.root;
970 }
971
972 /* Destroy an i386 ELF linker hash table.  */
973
974 static void
975 elf_i386_link_hash_table_free (struct bfd_link_hash_table *hash)
976 {
977   struct elf_i386_link_hash_table *htab
978     = (struct elf_i386_link_hash_table *) hash;
979
980   if (htab->loc_hash_table)
981     htab_delete (htab->loc_hash_table);
982   if (htab->loc_hash_memory)
983     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
984   _bfd_generic_link_hash_table_free (hash);
985 }
986
987 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
988    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
989    hash table.  */
990
991 static bfd_boolean
992 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
993 {
994   struct elf_i386_link_hash_table *htab;
995
996   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
997     return FALSE;
998
999   htab = elf_i386_hash_table (info);
1000   if (htab == NULL)
1001     return FALSE;
1002
1003   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1004   if (!info->shared)
1005     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
1006
1007   if (!htab->sdynbss
1008       || (!info->shared && !htab->srelbss))
1009     abort ();
1010
1011   if (get_elf_i386_backend_data (dynobj)->is_vxworks
1012       && !elf_vxworks_create_dynamic_sections (dynobj, info,
1013                                                &htab->srelplt2))
1014     return FALSE;
1015
1016   if (!info->no_ld_generated_unwind_info
1017       && bfd_get_section_by_name (dynobj, ".eh_frame") == NULL
1018       && htab->elf.splt != NULL)
1019     {
1020       flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
1021       htab->plt_eh_frame
1022         = bfd_make_section_with_flags (dynobj, ".eh_frame",
1023                                        flags | SEC_READONLY);
1024       if (htab->plt_eh_frame == NULL
1025           || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1026         return FALSE;
1027
1028       htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
1029       htab->plt_eh_frame->contents
1030         = bfd_alloc (dynobj, htab->plt_eh_frame->size);
1031       memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
1032               sizeof (elf_i386_eh_frame_plt));
1033     }
1034
1035   return TRUE;
1036 }
1037
1038 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1039
1040 static void
1041 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1042                                struct elf_link_hash_entry *dir,
1043                                struct elf_link_hash_entry *ind)
1044 {
1045   struct elf_i386_link_hash_entry *edir, *eind;
1046
1047   edir = (struct elf_i386_link_hash_entry *) dir;
1048   eind = (struct elf_i386_link_hash_entry *) ind;
1049
1050   if (eind->dyn_relocs != NULL)
1051     {
1052       if (edir->dyn_relocs != NULL)
1053         {
1054           struct elf_dyn_relocs **pp;
1055           struct elf_dyn_relocs *p;
1056
1057           /* Add reloc counts against the indirect sym to the direct sym
1058              list.  Merge any entries against the same section.  */
1059           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1060             {
1061               struct elf_dyn_relocs *q;
1062
1063               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1064                 if (q->sec == p->sec)
1065                   {
1066                     q->pc_count += p->pc_count;
1067                     q->count += p->count;
1068                     *pp = p->next;
1069                     break;
1070                   }
1071               if (q == NULL)
1072                 pp = &p->next;
1073             }
1074           *pp = edir->dyn_relocs;
1075         }
1076
1077       edir->dyn_relocs = eind->dyn_relocs;
1078       eind->dyn_relocs = NULL;
1079     }
1080
1081   if (ind->root.type == bfd_link_hash_indirect
1082       && dir->got.refcount <= 0)
1083     {
1084       edir->tls_type = eind->tls_type;
1085       eind->tls_type = GOT_UNKNOWN;
1086     }
1087
1088   if (ELIMINATE_COPY_RELOCS
1089       && ind->root.type != bfd_link_hash_indirect
1090       && dir->dynamic_adjusted)
1091     {
1092       /* If called to transfer flags for a weakdef during processing
1093          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1094          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1095       dir->ref_dynamic |= ind->ref_dynamic;
1096       dir->ref_regular |= ind->ref_regular;
1097       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1098       dir->needs_plt |= ind->needs_plt;
1099       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1100     }
1101   else
1102     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1103 }
1104
1105 /* Return TRUE if the TLS access code sequence support transition
1106    from R_TYPE.  */
1107
1108 static bfd_boolean
1109 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1110                                bfd_byte *contents,
1111                                Elf_Internal_Shdr *symtab_hdr,
1112                                struct elf_link_hash_entry **sym_hashes,
1113                                unsigned int r_type,
1114                                const Elf_Internal_Rela *rel,
1115                                const Elf_Internal_Rela *relend)
1116 {
1117   unsigned int val, type;
1118   unsigned long r_symndx;
1119   struct elf_link_hash_entry *h;
1120   bfd_vma offset;
1121
1122   /* Get the section contents.  */
1123   if (contents == NULL)
1124     {
1125       if (elf_section_data (sec)->this_hdr.contents != NULL)
1126         contents = elf_section_data (sec)->this_hdr.contents;
1127       else
1128         {
1129           /* FIXME: How to better handle error condition?  */
1130           if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1131             return FALSE;
1132
1133           /* Cache the section contents for elf_link_input_bfd.  */
1134           elf_section_data (sec)->this_hdr.contents = contents;
1135         }
1136     }
1137
1138   offset = rel->r_offset;
1139   switch (r_type)
1140     {
1141     case R_386_TLS_GD:
1142     case R_386_TLS_LDM:
1143       if (offset < 2 || (rel + 1) >= relend)
1144         return FALSE;
1145
1146       type = bfd_get_8 (abfd, contents + offset - 2);
1147       if (r_type == R_386_TLS_GD)
1148         {
1149           /* Check transition from GD access model.  Only
1150                 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1151                 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1152              can transit to different access model.  */
1153           if ((offset + 10) > sec->size ||
1154               (type != 0x8d && type != 0x04))
1155             return FALSE;
1156
1157           val = bfd_get_8 (abfd, contents + offset - 1);
1158           if (type == 0x04)
1159             {
1160               /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1161               if (offset < 3)
1162                 return FALSE;
1163
1164               if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1165                 return FALSE;
1166
1167               if ((val & 0xc7) != 0x05 || val == (4 << 3))
1168                 return FALSE;
1169             }
1170           else
1171             {
1172               /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop  */
1173               if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1174                 return FALSE;
1175
1176               if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1177                 return FALSE;
1178             }
1179         }
1180       else
1181         {
1182           /* Check transition from LD access model.  Only
1183                 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1184              can transit to different access model.  */
1185           if (type != 0x8d || (offset + 9) > sec->size)
1186             return FALSE;
1187
1188           val = bfd_get_8 (abfd, contents + offset - 1);
1189           if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1190             return FALSE;
1191         }
1192
1193       if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1194         return FALSE;
1195
1196       r_symndx = ELF32_R_SYM (rel[1].r_info);
1197       if (r_symndx < symtab_hdr->sh_info)
1198         return FALSE;
1199
1200       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1201       /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1202          may be versioned.  */
1203       return (h != NULL
1204               && h->root.root.string != NULL
1205               && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1206                   || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1207               && (strncmp (h->root.root.string, "___tls_get_addr",
1208                            15) == 0));
1209
1210     case R_386_TLS_IE:
1211       /* Check transition from IE access model:
1212                 movl foo@indntpoff(%rip), %eax
1213                 movl foo@indntpoff(%rip), %reg
1214                 addl foo@indntpoff(%rip), %reg
1215        */
1216
1217       if (offset < 1 || (offset + 4) > sec->size)
1218         return FALSE;
1219
1220       /* Check "movl foo@tpoff(%rip), %eax" first.  */
1221       val = bfd_get_8 (abfd, contents + offset - 1);
1222       if (val == 0xa1)
1223         return TRUE;
1224
1225       if (offset < 2)
1226         return FALSE;
1227
1228       /* Check movl|addl foo@tpoff(%rip), %reg.   */
1229       type = bfd_get_8 (abfd, contents + offset - 2);
1230       return ((type == 0x8b || type == 0x03)
1231               && (val & 0xc7) == 0x05);
1232
1233     case R_386_TLS_GOTIE:
1234     case R_386_TLS_IE_32:
1235       /* Check transition from {IE_32,GOTIE} access model:
1236                 subl foo@{tpoff,gontoff}(%reg1), %reg2
1237                 movl foo@{tpoff,gontoff}(%reg1), %reg2
1238                 addl foo@{tpoff,gontoff}(%reg1), %reg2
1239        */
1240
1241       if (offset < 2 || (offset + 4) > sec->size)
1242         return FALSE;
1243
1244       val = bfd_get_8 (abfd, contents + offset - 1);
1245       if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1246         return FALSE;
1247
1248       type = bfd_get_8 (abfd, contents + offset - 2);
1249       return type == 0x8b || type == 0x2b || type == 0x03;
1250
1251     case R_386_TLS_GOTDESC:
1252       /* Check transition from GDesc access model:
1253                 leal x@tlsdesc(%ebx), %eax
1254
1255          Make sure it's a leal adding ebx to a 32-bit offset
1256          into any register, although it's probably almost always
1257          going to be eax.  */
1258
1259       if (offset < 2 || (offset + 4) > sec->size)
1260         return FALSE;
1261
1262       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1263         return FALSE;
1264
1265       val = bfd_get_8 (abfd, contents + offset - 1);
1266       return (val & 0xc7) == 0x83;
1267
1268     case R_386_TLS_DESC_CALL:
1269       /* Check transition from GDesc access model:
1270                 call *x@tlsdesc(%rax)
1271        */
1272       if (offset + 2 <= sec->size)
1273         {
1274           /* Make sure that it's a call *x@tlsdesc(%rax).  */
1275           static const unsigned char call[] = { 0xff, 0x10 };
1276           return memcmp (contents + offset, call, 2) == 0;
1277         }
1278
1279       return FALSE;
1280
1281     default:
1282       abort ();
1283     }
1284 }
1285
1286 /* Return TRUE if the TLS access transition is OK or no transition
1287    will be performed.  Update R_TYPE if there is a transition.  */
1288
1289 static bfd_boolean
1290 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1291                          asection *sec, bfd_byte *contents,
1292                          Elf_Internal_Shdr *symtab_hdr,
1293                          struct elf_link_hash_entry **sym_hashes,
1294                          unsigned int *r_type, int tls_type,
1295                          const Elf_Internal_Rela *rel,
1296                          const Elf_Internal_Rela *relend,
1297                          struct elf_link_hash_entry *h,
1298                          unsigned long r_symndx)
1299 {
1300   unsigned int from_type = *r_type;
1301   unsigned int to_type = from_type;
1302   bfd_boolean check = TRUE;
1303
1304   /* Skip TLS transition for functions.  */
1305   if (h != NULL
1306       && (h->type == STT_FUNC
1307           || h->type == STT_GNU_IFUNC))
1308     return TRUE;
1309
1310   switch (from_type)
1311     {
1312     case R_386_TLS_GD:
1313     case R_386_TLS_GOTDESC:
1314     case R_386_TLS_DESC_CALL:
1315     case R_386_TLS_IE_32:
1316     case R_386_TLS_IE:
1317     case R_386_TLS_GOTIE:
1318       if (info->executable)
1319         {
1320           if (h == NULL)
1321             to_type = R_386_TLS_LE_32;
1322           else if (from_type != R_386_TLS_IE
1323                    && from_type != R_386_TLS_GOTIE)
1324             to_type = R_386_TLS_IE_32;
1325         }
1326
1327       /* When we are called from elf_i386_relocate_section, CONTENTS
1328          isn't NULL and there may be additional transitions based on
1329          TLS_TYPE.  */
1330       if (contents != NULL)
1331         {
1332           unsigned int new_to_type = to_type;
1333
1334           if (info->executable
1335               && h != NULL
1336               && h->dynindx == -1
1337               && (tls_type & GOT_TLS_IE))
1338             new_to_type = R_386_TLS_LE_32;
1339
1340           if (to_type == R_386_TLS_GD
1341               || to_type == R_386_TLS_GOTDESC
1342               || to_type == R_386_TLS_DESC_CALL)
1343             {
1344               if (tls_type == GOT_TLS_IE_POS)
1345                 new_to_type = R_386_TLS_GOTIE;
1346               else if (tls_type & GOT_TLS_IE)
1347                 new_to_type = R_386_TLS_IE_32;
1348             }
1349
1350           /* We checked the transition before when we were called from
1351              elf_i386_check_relocs.  We only want to check the new
1352              transition which hasn't been checked before.  */
1353           check = new_to_type != to_type && from_type == to_type;
1354           to_type = new_to_type;
1355         }
1356
1357       break;
1358
1359     case R_386_TLS_LDM:
1360       if (info->executable)
1361         to_type = R_386_TLS_LE_32;
1362       break;
1363
1364     default:
1365       return TRUE;
1366     }
1367
1368   /* Return TRUE if there is no transition.  */
1369   if (from_type == to_type)
1370     return TRUE;
1371
1372   /* Check if the transition can be performed.  */
1373   if (check
1374       && ! elf_i386_check_tls_transition (abfd, sec, contents,
1375                                           symtab_hdr, sym_hashes,
1376                                           from_type, rel, relend))
1377     {
1378       reloc_howto_type *from, *to;
1379       const char *name;
1380
1381       from = elf_i386_rtype_to_howto (abfd, from_type);
1382       to = elf_i386_rtype_to_howto (abfd, to_type);
1383
1384       if (h)
1385         name = h->root.root.string;
1386       else
1387         {
1388           struct elf_i386_link_hash_table *htab;
1389
1390           htab = elf_i386_hash_table (info);
1391           if (htab == NULL)
1392             name = "*unknown*";
1393           else
1394             {
1395               Elf_Internal_Sym *isym;
1396
1397               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1398                                             abfd, r_symndx);
1399               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1400             }
1401         }
1402
1403       (*_bfd_error_handler)
1404         (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1405            "in section `%A' failed"),
1406          abfd, sec, from->name, to->name, name,
1407          (unsigned long) rel->r_offset);
1408       bfd_set_error (bfd_error_bad_value);
1409       return FALSE;
1410     }
1411
1412   *r_type = to_type;
1413   return TRUE;
1414 }
1415
1416 /* Look through the relocs for a section during the first phase, and
1417    calculate needed space in the global offset table, procedure linkage
1418    table, and dynamic reloc sections.  */
1419
1420 static bfd_boolean
1421 elf_i386_check_relocs (bfd *abfd,
1422                        struct bfd_link_info *info,
1423                        asection *sec,
1424                        const Elf_Internal_Rela *relocs)
1425 {
1426   struct elf_i386_link_hash_table *htab;
1427   Elf_Internal_Shdr *symtab_hdr;
1428   struct elf_link_hash_entry **sym_hashes;
1429   const Elf_Internal_Rela *rel;
1430   const Elf_Internal_Rela *rel_end;
1431   asection *sreloc;
1432
1433   if (info->relocatable)
1434     return TRUE;
1435
1436   BFD_ASSERT (is_i386_elf (abfd));
1437
1438   htab = elf_i386_hash_table (info);
1439   if (htab == NULL)
1440     return FALSE;
1441
1442   symtab_hdr = &elf_symtab_hdr (abfd);
1443   sym_hashes = elf_sym_hashes (abfd);
1444
1445   sreloc = NULL;
1446
1447   rel_end = relocs + sec->reloc_count;
1448   for (rel = relocs; rel < rel_end; rel++)
1449     {
1450       unsigned int r_type;
1451       unsigned long r_symndx;
1452       struct elf_link_hash_entry *h;
1453       Elf_Internal_Sym *isym;
1454       const char *name;
1455
1456       r_symndx = ELF32_R_SYM (rel->r_info);
1457       r_type = ELF32_R_TYPE (rel->r_info);
1458
1459       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1460         {
1461           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1462                                  abfd,
1463                                  r_symndx);
1464           return FALSE;
1465         }
1466
1467       if (r_symndx < symtab_hdr->sh_info)
1468         {
1469           /* A local symbol.  */
1470           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1471                                         abfd, r_symndx);
1472           if (isym == NULL)
1473             return FALSE;
1474
1475           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1476           if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1477             {
1478               h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1479               if (h == NULL)
1480                 return FALSE;
1481
1482               /* Fake a STT_GNU_IFUNC symbol.  */
1483               h->type = STT_GNU_IFUNC;
1484               h->def_regular = 1;
1485               h->ref_regular = 1;
1486               h->forced_local = 1;
1487               h->root.type = bfd_link_hash_defined;
1488             }
1489           else
1490             h = NULL;
1491         }
1492       else
1493         {
1494           isym = NULL;
1495           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1496           while (h->root.type == bfd_link_hash_indirect
1497                  || h->root.type == bfd_link_hash_warning)
1498             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1499         }
1500
1501       if (h != NULL)
1502         {
1503           /* Create the ifunc sections for static executables.  If we
1504              never see an indirect function symbol nor we are building
1505              a static executable, those sections will be empty and
1506              won't appear in output.  */
1507           switch (r_type)
1508             {
1509             default:
1510               break;
1511
1512             case R_386_32:
1513             case R_386_PC32:
1514             case R_386_PLT32:
1515             case R_386_GOT32:
1516             case R_386_GOTOFF:
1517               if (htab->elf.dynobj == NULL)
1518                 htab->elf.dynobj = abfd;
1519               if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1520                 return FALSE;
1521               break;
1522             }
1523
1524           /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1525              it here if it is defined in a non-shared object.  */
1526           if (h->type == STT_GNU_IFUNC
1527               && h->def_regular)
1528             {
1529               /* It is referenced by a non-shared object. */
1530               h->ref_regular = 1;
1531               h->needs_plt = 1;
1532
1533               /* STT_GNU_IFUNC symbol must go through PLT.  */
1534               h->plt.refcount += 1;
1535
1536               /* STT_GNU_IFUNC needs dynamic sections.  */
1537               if (htab->elf.dynobj == NULL)
1538                 htab->elf.dynobj = abfd;
1539
1540               switch (r_type)
1541                 {
1542                 default:
1543                   if (h->root.root.string)
1544                     name = h->root.root.string;
1545                   else
1546                     name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1547                                              NULL);
1548                   (*_bfd_error_handler)
1549                     (_("%B: relocation %s against STT_GNU_IFUNC "
1550                        "symbol `%s' isn't handled by %s"), abfd,
1551                      elf_howto_table[r_type].name,
1552                      name, __FUNCTION__);
1553                   bfd_set_error (bfd_error_bad_value);
1554                   return FALSE;
1555
1556                 case R_386_32:
1557                   h->non_got_ref = 1;
1558                   h->pointer_equality_needed = 1;
1559                   if (info->shared)
1560                     {
1561                       /* We must copy these reloc types into the
1562                          output file.  Create a reloc section in
1563                          dynobj and make room for this reloc.  */
1564                       sreloc = _bfd_elf_create_ifunc_dyn_reloc
1565                         (abfd, info, sec, sreloc,
1566                          &((struct elf_i386_link_hash_entry *) h)->dyn_relocs);
1567                       if (sreloc == NULL)
1568                         return FALSE;
1569                     }
1570                   break;
1571
1572                 case R_386_PC32:
1573                   h->non_got_ref = 1;
1574                   break;
1575
1576                 case R_386_PLT32:
1577                   break;
1578
1579                 case R_386_GOT32:
1580                 case R_386_GOTOFF:
1581                   h->got.refcount += 1;
1582                   if (htab->elf.sgot == NULL
1583                       && !_bfd_elf_create_got_section (htab->elf.dynobj,
1584                                                        info))
1585                     return FALSE;
1586                   break;
1587                 }
1588
1589               continue;
1590             }
1591         }
1592
1593       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1594                                      symtab_hdr, sym_hashes,
1595                                      &r_type, GOT_UNKNOWN,
1596                                      rel, rel_end, h, r_symndx))
1597         return FALSE;
1598
1599       switch (r_type)
1600         {
1601         case R_386_TLS_LDM:
1602           htab->tls_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           h->needs_plt = 1;
1619           h->plt.refcount += 1;
1620           break;
1621
1622         case R_386_TLS_IE_32:
1623         case R_386_TLS_IE:
1624         case R_386_TLS_GOTIE:
1625           if (!info->executable)
1626             info->flags |= DF_STATIC_TLS;
1627           /* Fall through */
1628
1629         case R_386_GOT32:
1630         case R_386_TLS_GD:
1631         case R_386_TLS_GOTDESC:
1632         case R_386_TLS_DESC_CALL:
1633           /* This symbol requires a global offset table entry.  */
1634           {
1635             int tls_type, old_tls_type;
1636
1637             switch (r_type)
1638               {
1639               default:
1640               case R_386_GOT32: tls_type = GOT_NORMAL; break;
1641               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1642               case R_386_TLS_GOTDESC:
1643               case R_386_TLS_DESC_CALL:
1644                 tls_type = GOT_TLS_GDESC; break;
1645               case R_386_TLS_IE_32:
1646                 if (ELF32_R_TYPE (rel->r_info) == r_type)
1647                   tls_type = GOT_TLS_IE_NEG;
1648                 else
1649                   /* If this is a GD->IE transition, we may use either of
1650                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
1651                   tls_type = GOT_TLS_IE;
1652                 break;
1653               case R_386_TLS_IE:
1654               case R_386_TLS_GOTIE:
1655                 tls_type = GOT_TLS_IE_POS; break;
1656               }
1657
1658             if (h != NULL)
1659               {
1660                 h->got.refcount += 1;
1661                 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1662               }
1663             else
1664               {
1665                 bfd_signed_vma *local_got_refcounts;
1666
1667                 /* This is a global offset table entry for a local symbol.  */
1668                 local_got_refcounts = elf_local_got_refcounts (abfd);
1669                 if (local_got_refcounts == NULL)
1670                   {
1671                     bfd_size_type size;
1672
1673                     size = symtab_hdr->sh_info;
1674                     size *= (sizeof (bfd_signed_vma)
1675                              + sizeof (bfd_vma) + sizeof(char));
1676                     local_got_refcounts = (bfd_signed_vma *)
1677                         bfd_zalloc (abfd, size);
1678                     if (local_got_refcounts == NULL)
1679                       return FALSE;
1680                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1681                     elf_i386_local_tlsdesc_gotent (abfd)
1682                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1683                     elf_i386_local_got_tls_type (abfd)
1684                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1685                   }
1686                 local_got_refcounts[r_symndx] += 1;
1687                 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1688               }
1689
1690             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1691               tls_type |= old_tls_type;
1692             /* If a TLS symbol is accessed using IE at least once,
1693                there is no point to use dynamic model for it.  */
1694             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1695                      && (! GOT_TLS_GD_ANY_P (old_tls_type)
1696                          || (tls_type & GOT_TLS_IE) == 0))
1697               {
1698                 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1699                   tls_type = old_tls_type;
1700                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1701                          && GOT_TLS_GD_ANY_P (tls_type))
1702                   tls_type |= old_tls_type;
1703                 else
1704                   {
1705                     if (h)
1706                       name = h->root.root.string;
1707                     else
1708                       name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1709                                              NULL);
1710                     (*_bfd_error_handler)
1711                       (_("%B: `%s' accessed both as normal and "
1712                          "thread local symbol"),
1713                        abfd, name);
1714                     return FALSE;
1715                   }
1716               }
1717
1718             if (old_tls_type != tls_type)
1719               {
1720                 if (h != NULL)
1721                   elf_i386_hash_entry (h)->tls_type = tls_type;
1722                 else
1723                   elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1724               }
1725           }
1726           /* Fall through */
1727
1728         case R_386_GOTOFF:
1729         case R_386_GOTPC:
1730         create_got:
1731           if (htab->elf.sgot == NULL)
1732             {
1733               if (htab->elf.dynobj == NULL)
1734                 htab->elf.dynobj = abfd;
1735               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1736                 return FALSE;
1737             }
1738           if (r_type != R_386_TLS_IE)
1739             break;
1740           /* Fall through */
1741
1742         case R_386_TLS_LE_32:
1743         case R_386_TLS_LE:
1744           if (info->executable)
1745             break;
1746           info->flags |= DF_STATIC_TLS;
1747           /* Fall through */
1748
1749         case R_386_32:
1750         case R_386_PC32:
1751           if (h != NULL && info->executable)
1752             {
1753               /* If this reloc is in a read-only section, we might
1754                  need a copy reloc.  We can't check reliably at this
1755                  stage whether the section is read-only, as input
1756                  sections have not yet been mapped to output sections.
1757                  Tentatively set the flag for now, and correct in
1758                  adjust_dynamic_symbol.  */
1759               h->non_got_ref = 1;
1760
1761               /* We may need a .plt entry if the function this reloc
1762                  refers to is in a shared lib.  */
1763               h->plt.refcount += 1;
1764               if (r_type != R_386_PC32)
1765                 h->pointer_equality_needed = 1;
1766             }
1767
1768           /* If we are creating a shared library, and this is a reloc
1769              against a global symbol, or a non PC relative reloc
1770              against a local symbol, then we need to copy the reloc
1771              into the shared library.  However, if we are linking with
1772              -Bsymbolic, we do not need to copy a reloc against a
1773              global symbol which is defined in an object we are
1774              including in the link (i.e., DEF_REGULAR is set).  At
1775              this point we have not seen all the input files, so it is
1776              possible that DEF_REGULAR is not set now but will be set
1777              later (it is never cleared).  In case of a weak definition,
1778              DEF_REGULAR may be cleared later by a strong definition in
1779              a shared library.  We account for that possibility below by
1780              storing information in the relocs_copied field of the hash
1781              table entry.  A similar situation occurs when creating
1782              shared libraries and symbol visibility changes render the
1783              symbol local.
1784
1785              If on the other hand, we are creating an executable, we
1786              may need to keep relocations for symbols satisfied by a
1787              dynamic library if we manage to avoid copy relocs for the
1788              symbol.  */
1789           if ((info->shared
1790                && (sec->flags & SEC_ALLOC) != 0
1791                && (r_type != R_386_PC32
1792                    || (h != NULL
1793                        && (! SYMBOLIC_BIND (info, h)
1794                            || h->root.type == bfd_link_hash_defweak
1795                            || !h->def_regular))))
1796               || (ELIMINATE_COPY_RELOCS
1797                   && !info->shared
1798                   && (sec->flags & SEC_ALLOC) != 0
1799                   && h != NULL
1800                   && (h->root.type == bfd_link_hash_defweak
1801                       || !h->def_regular)))
1802             {
1803               struct elf_dyn_relocs *p;
1804               struct elf_dyn_relocs **head;
1805
1806               /* We must copy these reloc types into the output file.
1807                  Create a reloc section in dynobj and make room for
1808                  this reloc.  */
1809               if (sreloc == NULL)
1810                 {
1811                   if (htab->elf.dynobj == NULL)
1812                     htab->elf.dynobj = abfd;
1813
1814                   sreloc = _bfd_elf_make_dynamic_reloc_section
1815                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1816
1817                   if (sreloc == NULL)
1818                     return FALSE;
1819                 }
1820
1821               /* If this is a global symbol, we count the number of
1822                  relocations we need for this symbol.  */
1823               if (h != NULL)
1824                 {
1825                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1826                 }
1827               else
1828                 {
1829                   /* Track dynamic relocs needed for local syms too.
1830                      We really need local syms available to do this
1831                      easily.  Oh well.  */
1832                   void **vpp;
1833                   asection *s;
1834
1835                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1836                                                 abfd, r_symndx);
1837                   if (isym == NULL)
1838                     return FALSE;
1839
1840                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1841                   if (s == NULL)
1842                     s = sec;
1843
1844                   vpp = &elf_section_data (s)->local_dynrel;
1845                   head = (struct elf_dyn_relocs **)vpp;
1846                 }
1847
1848               p = *head;
1849               if (p == NULL || p->sec != sec)
1850                 {
1851                   bfd_size_type amt = sizeof *p;
1852                   p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1853                                                            amt);
1854                   if (p == NULL)
1855                     return FALSE;
1856                   p->next = *head;
1857                   *head = p;
1858                   p->sec = sec;
1859                   p->count = 0;
1860                   p->pc_count = 0;
1861                 }
1862
1863               p->count += 1;
1864               if (r_type == R_386_PC32)
1865                 p->pc_count += 1;
1866             }
1867           break;
1868
1869           /* This relocation describes the C++ object vtable hierarchy.
1870              Reconstruct it for later use during GC.  */
1871         case R_386_GNU_VTINHERIT:
1872           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1873             return FALSE;
1874           break;
1875
1876           /* This relocation describes which C++ vtable entries are actually
1877              used.  Record for later use during GC.  */
1878         case R_386_GNU_VTENTRY:
1879           BFD_ASSERT (h != NULL);
1880           if (h != NULL
1881               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1882             return FALSE;
1883           break;
1884
1885         default:
1886           break;
1887         }
1888     }
1889
1890   return TRUE;
1891 }
1892
1893 /* Return the section that should be marked against GC for a given
1894    relocation.  */
1895
1896 static asection *
1897 elf_i386_gc_mark_hook (asection *sec,
1898                        struct bfd_link_info *info,
1899                        Elf_Internal_Rela *rel,
1900                        struct elf_link_hash_entry *h,
1901                        Elf_Internal_Sym *sym)
1902 {
1903   if (h != NULL)
1904     switch (ELF32_R_TYPE (rel->r_info))
1905       {
1906       case R_386_GNU_VTINHERIT:
1907       case R_386_GNU_VTENTRY:
1908         return NULL;
1909       }
1910
1911   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1912 }
1913
1914 /* Update the got entry reference counts for the section being removed.  */
1915
1916 static bfd_boolean
1917 elf_i386_gc_sweep_hook (bfd *abfd,
1918                         struct bfd_link_info *info,
1919                         asection *sec,
1920                         const Elf_Internal_Rela *relocs)
1921 {
1922   struct elf_i386_link_hash_table *htab;
1923   Elf_Internal_Shdr *symtab_hdr;
1924   struct elf_link_hash_entry **sym_hashes;
1925   bfd_signed_vma *local_got_refcounts;
1926   const Elf_Internal_Rela *rel, *relend;
1927
1928   if (info->relocatable)
1929     return TRUE;
1930
1931   htab = elf_i386_hash_table (info);
1932   if (htab == NULL)
1933     return FALSE;
1934
1935   elf_section_data (sec)->local_dynrel = NULL;
1936
1937   symtab_hdr = &elf_symtab_hdr (abfd);
1938   sym_hashes = elf_sym_hashes (abfd);
1939   local_got_refcounts = elf_local_got_refcounts (abfd);
1940
1941   relend = relocs + sec->reloc_count;
1942   for (rel = relocs; rel < relend; rel++)
1943     {
1944       unsigned long r_symndx;
1945       unsigned int r_type;
1946       struct elf_link_hash_entry *h = NULL;
1947
1948       r_symndx = ELF32_R_SYM (rel->r_info);
1949       if (r_symndx >= symtab_hdr->sh_info)
1950         {
1951           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1952           while (h->root.type == bfd_link_hash_indirect
1953                  || h->root.type == bfd_link_hash_warning)
1954             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1955         }
1956       else
1957         {
1958           /* A local symbol.  */
1959           Elf_Internal_Sym *isym;
1960
1961           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1962                                         abfd, r_symndx);
1963
1964           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1965           if (isym != NULL
1966               && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1967             {
1968               h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
1969               if (h == NULL)
1970                 abort ();
1971             }
1972         }
1973
1974       if (h)
1975         {
1976           struct elf_i386_link_hash_entry *eh;
1977           struct elf_dyn_relocs **pp;
1978           struct elf_dyn_relocs *p;
1979
1980           eh = (struct elf_i386_link_hash_entry *) h;
1981           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1982             if (p->sec == sec)
1983               {
1984                 /* Everything must go for SEC.  */
1985                 *pp = p->next;
1986                 break;
1987               }
1988         }
1989
1990       r_type = ELF32_R_TYPE (rel->r_info);
1991       if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1992                                      symtab_hdr, sym_hashes,
1993                                      &r_type, GOT_UNKNOWN,
1994                                      rel, relend, h, r_symndx))
1995         return FALSE;
1996
1997       switch (r_type)
1998         {
1999         case R_386_TLS_LDM:
2000           if (htab->tls_ldm_got.refcount > 0)
2001             htab->tls_ldm_got.refcount -= 1;
2002           break;
2003
2004         case R_386_TLS_GD:
2005         case R_386_TLS_GOTDESC:
2006         case R_386_TLS_DESC_CALL:
2007         case R_386_TLS_IE_32:
2008         case R_386_TLS_IE:
2009         case R_386_TLS_GOTIE:
2010         case R_386_GOT32:
2011           if (h != NULL)
2012             {
2013               if (h->got.refcount > 0)
2014                 h->got.refcount -= 1;
2015               if (h->type == STT_GNU_IFUNC)
2016                 {
2017                   if (h->plt.refcount > 0)
2018                     h->plt.refcount -= 1;
2019                 }
2020             }
2021           else if (local_got_refcounts != NULL)
2022             {
2023               if (local_got_refcounts[r_symndx] > 0)
2024                 local_got_refcounts[r_symndx] -= 1;
2025             }
2026           break;
2027
2028         case R_386_32:
2029         case R_386_PC32:
2030           if (info->shared
2031               && (h == NULL || h->type != STT_GNU_IFUNC))
2032             break;
2033           /* Fall through */
2034
2035         case R_386_PLT32:
2036           if (h != NULL)
2037             {
2038               if (h->plt.refcount > 0)
2039                 h->plt.refcount -= 1;
2040             }
2041           break;
2042
2043         case R_386_GOTOFF:
2044           if (h != NULL && h->type == STT_GNU_IFUNC)
2045             {
2046               if (h->got.refcount > 0)
2047                 h->got.refcount -= 1;
2048               if (h->plt.refcount > 0)
2049                 h->plt.refcount -= 1;
2050             }
2051           break;
2052
2053         default:
2054           break;
2055         }
2056     }
2057
2058   return TRUE;
2059 }
2060
2061 /* Adjust a symbol defined by a dynamic object and referenced by a
2062    regular object.  The current definition is in some section of the
2063    dynamic object, but we're not including those sections.  We have to
2064    change the definition to something the rest of the link can
2065    understand.  */
2066
2067 static bfd_boolean
2068 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2069                                 struct elf_link_hash_entry *h)
2070 {
2071   struct elf_i386_link_hash_table *htab;
2072   asection *s;
2073
2074   /* STT_GNU_IFUNC symbol must go through PLT. */
2075   if (h->type == STT_GNU_IFUNC)
2076     {
2077       if (h->plt.refcount <= 0)
2078         {
2079           h->plt.offset = (bfd_vma) -1;
2080           h->needs_plt = 0;
2081         }
2082       return TRUE;
2083     }
2084
2085   /* If this is a function, put it in the procedure linkage table.  We
2086      will fill in the contents of the procedure linkage table later,
2087      when we know the address of the .got section.  */
2088   if (h->type == STT_FUNC
2089       || h->needs_plt)
2090     {
2091       if (h->plt.refcount <= 0
2092           || SYMBOL_CALLS_LOCAL (info, h)
2093           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2094               && h->root.type == bfd_link_hash_undefweak))
2095         {
2096           /* This case can occur if we saw a PLT32 reloc in an input
2097              file, but the symbol was never referred to by a dynamic
2098              object, or if all references were garbage collected.  In
2099              such a case, we don't actually need to build a procedure
2100              linkage table, and we can just do a PC32 reloc instead.  */
2101           h->plt.offset = (bfd_vma) -1;
2102           h->needs_plt = 0;
2103         }
2104
2105       return TRUE;
2106     }
2107   else
2108     /* It's possible that we incorrectly decided a .plt reloc was
2109        needed for an R_386_PC32 reloc to a non-function sym in
2110        check_relocs.  We can't decide accurately between function and
2111        non-function syms in check-relocs;  Objects loaded later in
2112        the link may change h->type.  So fix it now.  */
2113     h->plt.offset = (bfd_vma) -1;
2114
2115   /* If this is a weak symbol, and there is a real definition, the
2116      processor independent code will have arranged for us to see the
2117      real definition first, and we can just use the same value.  */
2118   if (h->u.weakdef != NULL)
2119     {
2120       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2121                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2122       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2123       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2124       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2125         h->non_got_ref = h->u.weakdef->non_got_ref;
2126       return TRUE;
2127     }
2128
2129   /* This is a reference to a symbol defined by a dynamic object which
2130      is not a function.  */
2131
2132   /* If we are creating a shared library, we must presume that the
2133      only references to the symbol are via the global offset table.
2134      For such cases we need not do anything here; the relocations will
2135      be handled correctly by relocate_section.  */
2136   if (info->shared)
2137     return TRUE;
2138
2139   /* If there are no references to this symbol that do not use the
2140      GOT, we don't need to generate a copy reloc.  */
2141   if (!h->non_got_ref)
2142     return TRUE;
2143
2144   /* If -z nocopyreloc was given, we won't generate them either.  */
2145   if (info->nocopyreloc)
2146     {
2147       h->non_got_ref = 0;
2148       return TRUE;
2149     }
2150
2151   htab = elf_i386_hash_table (info);
2152   if (htab == NULL)
2153     return FALSE;
2154
2155   /* If there aren't any dynamic relocs in read-only sections, then
2156      we can keep the dynamic relocs and avoid the copy reloc.  This
2157      doesn't work on VxWorks, where we can not have dynamic relocations
2158      (other than copy and jump slot relocations) in an executable.  */
2159   if (ELIMINATE_COPY_RELOCS
2160       && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2161     {
2162       struct elf_i386_link_hash_entry * eh;
2163       struct elf_dyn_relocs *p;
2164
2165       eh = (struct elf_i386_link_hash_entry *) h;
2166       for (p = eh->dyn_relocs; p != NULL; p = p->next)
2167         {
2168           s = p->sec->output_section;
2169           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2170             break;
2171         }
2172
2173       if (p == NULL)
2174         {
2175           h->non_got_ref = 0;
2176           return TRUE;
2177         }
2178     }
2179
2180   if (h->size == 0)
2181     {
2182       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2183                              h->root.root.string);
2184       return TRUE;
2185     }
2186
2187   /* We must allocate the symbol in our .dynbss section, which will
2188      become part of the .bss section of the executable.  There will be
2189      an entry for this symbol in the .dynsym section.  The dynamic
2190      object will contain position independent code, so all references
2191      from the dynamic object to this symbol will go through the global
2192      offset table.  The dynamic linker will use the .dynsym entry to
2193      determine the address it must put in the global offset table, so
2194      both the dynamic object and the regular object will refer to the
2195      same memory location for the variable.  */
2196
2197   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2198      copy the initial value out of the dynamic object and into the
2199      runtime process image.  */
2200   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2201     {
2202       htab->srelbss->size += sizeof (Elf32_External_Rel);
2203       h->needs_copy = 1;
2204     }
2205
2206   s = htab->sdynbss;
2207
2208   return _bfd_elf_adjust_dynamic_copy (h, s);
2209 }
2210
2211 /* Allocate space in .plt, .got and associated reloc sections for
2212    dynamic relocs.  */
2213
2214 static bfd_boolean
2215 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2216 {
2217   struct bfd_link_info *info;
2218   struct elf_i386_link_hash_table *htab;
2219   struct elf_i386_link_hash_entry *eh;
2220   struct elf_dyn_relocs *p;
2221   unsigned plt_entry_size;
2222
2223   if (h->root.type == bfd_link_hash_indirect)
2224     return TRUE;
2225
2226   eh = (struct elf_i386_link_hash_entry *) h;
2227
2228   info = (struct bfd_link_info *) inf;
2229   htab = elf_i386_hash_table (info);
2230   if (htab == NULL)
2231     return FALSE;
2232
2233   plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2234
2235   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2236      here if it is defined and referenced in a non-shared object.  */
2237   if (h->type == STT_GNU_IFUNC
2238       && h->def_regular)
2239     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2240                                                plt_entry_size, 4);
2241   else if (htab->elf.dynamic_sections_created
2242            && h->plt.refcount > 0)
2243     {
2244       /* Make sure this symbol is output as a dynamic symbol.
2245          Undefined weak syms won't yet be marked as dynamic.  */
2246       if (h->dynindx == -1
2247           && !h->forced_local)
2248         {
2249           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2250             return FALSE;
2251         }
2252
2253       if (info->shared
2254           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2255         {
2256           asection *s = htab->elf.splt;
2257
2258           /* If this is the first .plt entry, make room for the special
2259              first entry.  */
2260           if (s->size == 0)
2261             s->size += plt_entry_size;
2262
2263           h->plt.offset = s->size;
2264
2265           /* If this symbol is not defined in a regular file, and we are
2266              not generating a shared library, then set the symbol to this
2267              location in the .plt.  This is required to make function
2268              pointers compare as equal between the normal executable and
2269              the shared library.  */
2270           if (! info->shared
2271               && !h->def_regular)
2272             {
2273               h->root.u.def.section = s;
2274               h->root.u.def.value = h->plt.offset;
2275             }
2276
2277           /* Make room for this entry.  */
2278           s->size += plt_entry_size;
2279
2280           /* We also need to make an entry in the .got.plt section, which
2281              will be placed in the .got section by the linker script.  */
2282           htab->elf.sgotplt->size += 4;
2283
2284           /* We also need to make an entry in the .rel.plt section.  */
2285           htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2286           htab->elf.srelplt->reloc_count++;
2287
2288           if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2289               && !info->shared)
2290             {
2291               /* VxWorks has a second set of relocations for each PLT entry
2292                  in executables.  They go in a separate relocation section,
2293                  which is processed by the kernel loader.  */
2294
2295               /* There are two relocations for the initial PLT entry: an
2296                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2297                  R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
2298
2299               if (h->plt.offset == plt_entry_size)
2300                 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2301
2302               /* There are two extra relocations for each subsequent PLT entry:
2303                  an R_386_32 relocation for the GOT entry, and an R_386_32
2304                  relocation for the PLT entry.  */
2305
2306               htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2307             }
2308         }
2309       else
2310         {
2311           h->plt.offset = (bfd_vma) -1;
2312           h->needs_plt = 0;
2313         }
2314     }
2315   else
2316     {
2317       h->plt.offset = (bfd_vma) -1;
2318       h->needs_plt = 0;
2319     }
2320
2321   eh->tlsdesc_got = (bfd_vma) -1;
2322
2323   /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2324      make it a R_386_TLS_LE_32 requiring no TLS entry.  */
2325   if (h->got.refcount > 0
2326       && info->executable
2327       && h->dynindx == -1
2328       && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2329     h->got.offset = (bfd_vma) -1;
2330   else if (h->got.refcount > 0)
2331     {
2332       asection *s;
2333       bfd_boolean dyn;
2334       int tls_type = elf_i386_hash_entry(h)->tls_type;
2335
2336       /* Make sure this symbol is output as a dynamic symbol.
2337          Undefined weak syms won't yet be marked as dynamic.  */
2338       if (h->dynindx == -1
2339           && !h->forced_local)
2340         {
2341           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2342             return FALSE;
2343         }
2344
2345       s = htab->elf.sgot;
2346       if (GOT_TLS_GDESC_P (tls_type))
2347         {
2348           eh->tlsdesc_got = htab->elf.sgotplt->size
2349             - elf_i386_compute_jump_table_size (htab);
2350           htab->elf.sgotplt->size += 8;
2351           h->got.offset = (bfd_vma) -2;
2352         }
2353       if (! GOT_TLS_GDESC_P (tls_type)
2354           || GOT_TLS_GD_P (tls_type))
2355         {
2356           h->got.offset = s->size;
2357           s->size += 4;
2358           /* R_386_TLS_GD needs 2 consecutive GOT slots.  */
2359           if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2360             s->size += 4;
2361         }
2362       dyn = htab->elf.dynamic_sections_created;
2363       /* R_386_TLS_IE_32 needs one dynamic relocation,
2364          R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2365          (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2366          need two), R_386_TLS_GD needs one if local symbol and two if
2367          global.  */
2368       if (tls_type == GOT_TLS_IE_BOTH)
2369         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2370       else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2371                || (tls_type & GOT_TLS_IE))
2372         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2373       else if (GOT_TLS_GD_P (tls_type))
2374         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2375       else if (! GOT_TLS_GDESC_P (tls_type)
2376                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2377                    || h->root.type != bfd_link_hash_undefweak)
2378                && (info->shared
2379                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2380         htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2381       if (GOT_TLS_GDESC_P (tls_type))
2382         htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2383     }
2384   else
2385     h->got.offset = (bfd_vma) -1;
2386
2387   if (eh->dyn_relocs == NULL)
2388     return TRUE;
2389
2390   /* In the shared -Bsymbolic case, discard space allocated for
2391      dynamic pc-relative relocs against symbols which turn out to be
2392      defined in regular objects.  For the normal shared case, discard
2393      space for pc-relative relocs that have become local due to symbol
2394      visibility changes.  */
2395
2396   if (info->shared)
2397     {
2398       /* The only reloc that uses pc_count is R_386_PC32, which will
2399          appear on a call or on something like ".long foo - .".  We
2400          want calls to protected symbols to resolve directly to the
2401          function rather than going via the plt.  If people want
2402          function pointer comparisons to work as expected then they
2403          should avoid writing assembly like ".long foo - .".  */
2404       if (SYMBOL_CALLS_LOCAL (info, h))
2405         {
2406           struct elf_dyn_relocs **pp;
2407
2408           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2409             {
2410               p->count -= p->pc_count;
2411               p->pc_count = 0;
2412               if (p->count == 0)
2413                 *pp = p->next;
2414               else
2415                 pp = &p->next;
2416             }
2417         }
2418
2419       if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2420         {
2421           struct elf_dyn_relocs **pp;
2422           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2423             {
2424               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2425                 *pp = p->next;
2426               else
2427                 pp = &p->next;
2428             }
2429         }
2430
2431       /* Also discard relocs on undefined weak syms with non-default
2432          visibility.  */
2433       if (eh->dyn_relocs != NULL
2434           && h->root.type == bfd_link_hash_undefweak)
2435         {
2436           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2437             eh->dyn_relocs = NULL;
2438
2439           /* Make sure undefined weak symbols are output as a dynamic
2440              symbol in PIEs.  */
2441           else if (h->dynindx == -1
2442                    && !h->forced_local)
2443             {
2444               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2445                 return FALSE;
2446             }
2447         }
2448     }
2449   else if (ELIMINATE_COPY_RELOCS)
2450     {
2451       /* For the non-shared case, discard space for relocs against
2452          symbols which turn out to need copy relocs or are not
2453          dynamic.  */
2454
2455       if (!h->non_got_ref
2456           && ((h->def_dynamic
2457                && !h->def_regular)
2458               || (htab->elf.dynamic_sections_created
2459                   && (h->root.type == bfd_link_hash_undefweak
2460                       || h->root.type == bfd_link_hash_undefined))))
2461         {
2462           /* Make sure this symbol is output as a dynamic symbol.
2463              Undefined weak syms won't yet be marked as dynamic.  */
2464           if (h->dynindx == -1
2465               && !h->forced_local)
2466             {
2467               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2468                 return FALSE;
2469             }
2470
2471           /* If that succeeded, we know we'll be keeping all the
2472              relocs.  */
2473           if (h->dynindx != -1)
2474             goto keep;
2475         }
2476
2477       eh->dyn_relocs = NULL;
2478
2479     keep: ;
2480     }
2481
2482   /* Finally, allocate space.  */
2483   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2484     {
2485       asection *sreloc;
2486
2487       sreloc = elf_section_data (p->sec)->sreloc;
2488
2489       BFD_ASSERT (sreloc != NULL);
2490       sreloc->size += p->count * sizeof (Elf32_External_Rel);
2491     }
2492
2493   return TRUE;
2494 }
2495
2496 /* Allocate space in .plt, .got and associated reloc sections for
2497    local dynamic relocs.  */
2498
2499 static bfd_boolean
2500 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2501 {
2502   struct elf_link_hash_entry *h
2503     = (struct elf_link_hash_entry *) *slot;
2504
2505   if (h->type != STT_GNU_IFUNC
2506       || !h->def_regular
2507       || !h->ref_regular
2508       || !h->forced_local
2509       || h->root.type != bfd_link_hash_defined)
2510     abort ();
2511
2512   return elf_i386_allocate_dynrelocs (h, inf);
2513 }
2514
2515 /* Find any dynamic relocs that apply to read-only sections.  */
2516
2517 static bfd_boolean
2518 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2519 {
2520   struct elf_i386_link_hash_entry *eh;
2521   struct elf_dyn_relocs *p;
2522
2523   /* Skip local IFUNC symbols. */
2524   if (h->forced_local && h->type == STT_GNU_IFUNC)
2525     return TRUE;
2526
2527   eh = (struct elf_i386_link_hash_entry *) h;
2528   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2529     {
2530       asection *s = p->sec->output_section;
2531
2532       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2533         {
2534           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2535
2536           info->flags |= DF_TEXTREL;
2537
2538           if (info->warn_shared_textrel && info->shared)
2539             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2540                                     p->sec->owner, h->root.root.string,
2541                                     p->sec);
2542
2543           /* Not an error, just cut short the traversal.  */
2544           return FALSE;
2545         }
2546     }
2547   return TRUE;
2548 }
2549
2550 /* Set the sizes of the dynamic sections.  */
2551
2552 static bfd_boolean
2553 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2554 {
2555   struct elf_i386_link_hash_table *htab;
2556   bfd *dynobj;
2557   asection *s;
2558   bfd_boolean relocs;
2559   bfd *ibfd;
2560
2561   htab = elf_i386_hash_table (info);
2562   if (htab == NULL)
2563     return FALSE;
2564   dynobj = htab->elf.dynobj;
2565   if (dynobj == NULL)
2566     abort ();
2567
2568   if (htab->elf.dynamic_sections_created)
2569     {
2570       /* Set the contents of the .interp section to the interpreter.  */
2571       if (info->executable)
2572         {
2573           s = bfd_get_section_by_name (dynobj, ".interp");
2574           if (s == NULL)
2575             abort ();
2576           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2577           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2578         }
2579     }
2580
2581   /* Set up .got offsets for local syms, and space for local dynamic
2582      relocs.  */
2583   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2584     {
2585       bfd_signed_vma *local_got;
2586       bfd_signed_vma *end_local_got;
2587       char *local_tls_type;
2588       bfd_vma *local_tlsdesc_gotent;
2589       bfd_size_type locsymcount;
2590       Elf_Internal_Shdr *symtab_hdr;
2591       asection *srel;
2592
2593       if (! is_i386_elf (ibfd))
2594         continue;
2595
2596       for (s = ibfd->sections; s != NULL; s = s->next)
2597         {
2598           struct elf_dyn_relocs *p;
2599
2600           for (p = ((struct elf_dyn_relocs *)
2601                      elf_section_data (s)->local_dynrel);
2602                p != NULL;
2603                p = p->next)
2604             {
2605               if (!bfd_is_abs_section (p->sec)
2606                   && bfd_is_abs_section (p->sec->output_section))
2607                 {
2608                   /* Input section has been discarded, either because
2609                      it is a copy of a linkonce section or due to
2610                      linker script /DISCARD/, so we'll be discarding
2611                      the relocs too.  */
2612                 }
2613               else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2614                        && strcmp (p->sec->output_section->name,
2615                                   ".tls_vars") == 0)
2616                 {
2617                   /* Relocations in vxworks .tls_vars sections are
2618                      handled specially by the loader.  */
2619                 }
2620               else if (p->count != 0)
2621                 {
2622                   srel = elf_section_data (p->sec)->sreloc;
2623                   srel->size += p->count * sizeof (Elf32_External_Rel);
2624                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2625                       && (info->flags & DF_TEXTREL) == 0)
2626                     {
2627                       info->flags |= DF_TEXTREL;
2628                       if (info->warn_shared_textrel && info->shared)
2629                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2630                                                 p->sec->owner, p->sec);
2631                     }
2632                 }
2633             }
2634         }
2635
2636       local_got = elf_local_got_refcounts (ibfd);
2637       if (!local_got)
2638         continue;
2639
2640       symtab_hdr = &elf_symtab_hdr (ibfd);
2641       locsymcount = symtab_hdr->sh_info;
2642       end_local_got = local_got + locsymcount;
2643       local_tls_type = elf_i386_local_got_tls_type (ibfd);
2644       local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
2645       s = htab->elf.sgot;
2646       srel = htab->elf.srelgot;
2647       for (; local_got < end_local_got;
2648            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2649         {
2650           *local_tlsdesc_gotent = (bfd_vma) -1;
2651           if (*local_got > 0)
2652             {
2653               if (GOT_TLS_GDESC_P (*local_tls_type))
2654                 {
2655                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2656                     - elf_i386_compute_jump_table_size (htab);
2657                   htab->elf.sgotplt->size += 8;
2658                   *local_got = (bfd_vma) -2;
2659                 }
2660               if (! GOT_TLS_GDESC_P (*local_tls_type)
2661                   || GOT_TLS_GD_P (*local_tls_type))
2662                 {
2663                   *local_got = s->size;
2664                   s->size += 4;
2665                   if (GOT_TLS_GD_P (*local_tls_type)
2666                       || *local_tls_type == GOT_TLS_IE_BOTH)
2667                     s->size += 4;
2668                 }
2669               if (info->shared
2670                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2671                   || (*local_tls_type & GOT_TLS_IE))
2672                 {
2673                   if (*local_tls_type == GOT_TLS_IE_BOTH)
2674                     srel->size += 2 * sizeof (Elf32_External_Rel);
2675                   else if (GOT_TLS_GD_P (*local_tls_type)
2676                            || ! GOT_TLS_GDESC_P (*local_tls_type))
2677                     srel->size += sizeof (Elf32_External_Rel);
2678                   if (GOT_TLS_GDESC_P (*local_tls_type))
2679                     htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2680                 }
2681             }
2682           else
2683             *local_got = (bfd_vma) -1;
2684         }
2685     }
2686
2687   if (htab->tls_ldm_got.refcount > 0)
2688     {
2689       /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2690          relocs.  */
2691       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2692       htab->elf.sgot->size += 8;
2693       htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2694     }
2695   else
2696     htab->tls_ldm_got.offset = -1;
2697
2698   /* Allocate global sym .plt and .got entries, and space for global
2699      sym dynamic relocs.  */
2700   elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2701
2702   /* Allocate .plt and .got entries, and space for local symbols.  */
2703   htab_traverse (htab->loc_hash_table,
2704                  elf_i386_allocate_local_dynrelocs,
2705                  info);
2706
2707   /* For every jump slot reserved in the sgotplt, reloc_count is
2708      incremented.  However, when we reserve space for TLS descriptors,
2709      it's not incremented, so in order to compute the space reserved
2710      for them, it suffices to multiply the reloc count by the jump
2711      slot size.
2712      
2713      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2714      so that R_386_IRELATIVE entries come last.  */
2715   if (htab->elf.srelplt)
2716     {
2717       htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2718       htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2719       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2720     }
2721   else if (htab->elf.irelplt)
2722     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2723
2724
2725   if (htab->elf.sgotplt)
2726     {
2727       struct elf_link_hash_entry *got;
2728       got = elf_link_hash_lookup (elf_hash_table (info),
2729                                   "_GLOBAL_OFFSET_TABLE_",
2730                                   FALSE, FALSE, FALSE);
2731
2732       /* Don't allocate .got.plt section if there are no GOT nor PLT
2733          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2734       if ((got == NULL
2735            || !got->ref_regular_nonweak)
2736           && (htab->elf.sgotplt->size
2737               == get_elf_backend_data (output_bfd)->got_header_size)
2738           && (htab->elf.splt == NULL
2739               || htab->elf.splt->size == 0)
2740           && (htab->elf.sgot == NULL
2741               || htab->elf.sgot->size == 0)
2742           && (htab->elf.iplt == NULL
2743               || htab->elf.iplt->size == 0)
2744           && (htab->elf.igotplt == NULL
2745               || htab->elf.igotplt->size == 0))
2746         htab->elf.sgotplt->size = 0;
2747     }
2748
2749   /* We now have determined the sizes of the various dynamic sections.
2750      Allocate memory for them.  */
2751   relocs = FALSE;
2752   for (s = dynobj->sections; s != NULL; s = s->next)
2753     {
2754       bfd_boolean strip_section = TRUE;
2755
2756       if ((s->flags & SEC_LINKER_CREATED) == 0)
2757         continue;
2758
2759       if (s == htab->elf.splt
2760           || s == htab->elf.sgot
2761           || s == htab->elf.sgotplt
2762           || s == htab->elf.iplt
2763           || s == htab->elf.igotplt
2764           || s == htab->sdynbss)
2765         {
2766           /* Strip this section if we don't need it; see the
2767              comment below.  */
2768           /* We'd like to strip these sections if they aren't needed, but if
2769              we've exported dynamic symbols from them we must leave them.
2770              It's too late to tell BFD to get rid of the symbols.  */
2771
2772           if (htab->elf.hplt != NULL)
2773             strip_section = FALSE;
2774         }
2775       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
2776         {
2777           if (s->size != 0
2778               && s != htab->elf.srelplt
2779               && s != htab->srelplt2)
2780             relocs = TRUE;
2781
2782           /* We use the reloc_count field as a counter if we need
2783              to copy relocs into the output file.  */
2784           s->reloc_count = 0;
2785         }
2786       else
2787         {
2788           /* It's not one of our sections, so don't allocate space.  */
2789           continue;
2790         }
2791
2792       if (s->size == 0)
2793         {
2794           /* If we don't need this section, strip it from the
2795              output file.  This is mostly to handle .rel.bss and
2796              .rel.plt.  We must create both sections in
2797              create_dynamic_sections, because they must be created
2798              before the linker maps input sections to output
2799              sections.  The linker does that before
2800              adjust_dynamic_symbol is called, and it is that
2801              function which decides whether anything needs to go
2802              into these sections.  */
2803           if (strip_section)
2804             s->flags |= SEC_EXCLUDE;
2805           continue;
2806         }
2807
2808       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2809         continue;
2810
2811       /* Allocate memory for the section contents.  We use bfd_zalloc
2812          here in case unused entries are not reclaimed before the
2813          section's contents are written out.  This should not happen,
2814          but this way if it does, we get a R_386_NONE reloc instead
2815          of garbage.  */
2816       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2817       if (s->contents == NULL)
2818         return FALSE;
2819     }
2820
2821   if (htab->plt_eh_frame != NULL
2822       && htab->elf.splt != NULL
2823       && htab->elf.splt->size != 0
2824       && (htab->elf.splt->flags & SEC_EXCLUDE) == 0)
2825     bfd_put_32 (dynobj, htab->elf.splt->size,
2826                 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2827
2828   if (htab->elf.dynamic_sections_created)
2829     {
2830       /* Add some entries to the .dynamic section.  We fill in the
2831          values later, in elf_i386_finish_dynamic_sections, but we
2832          must add the entries now so that we get the correct size for
2833          the .dynamic section.  The DT_DEBUG entry is filled in by the
2834          dynamic linker and used by the debugger.  */
2835 #define add_dynamic_entry(TAG, VAL) \
2836   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2837
2838       if (info->executable)
2839         {
2840           if (!add_dynamic_entry (DT_DEBUG, 0))
2841             return FALSE;
2842         }
2843
2844       if (htab->elf.splt->size != 0)
2845         {
2846           if (!add_dynamic_entry (DT_PLTGOT, 0)
2847               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2848               || !add_dynamic_entry (DT_PLTREL, DT_REL)
2849               || !add_dynamic_entry (DT_JMPREL, 0))
2850             return FALSE;
2851         }
2852
2853       if (relocs)
2854         {
2855           if (!add_dynamic_entry (DT_REL, 0)
2856               || !add_dynamic_entry (DT_RELSZ, 0)
2857               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
2858             return FALSE;
2859
2860           /* If any dynamic relocs apply to a read-only section,
2861              then we need a DT_TEXTREL entry.  */
2862           if ((info->flags & DF_TEXTREL) == 0)
2863             elf_link_hash_traverse (&htab->elf,
2864                                     elf_i386_readonly_dynrelocs, info);
2865
2866           if ((info->flags & DF_TEXTREL) != 0)
2867             {
2868               if (!add_dynamic_entry (DT_TEXTREL, 0))
2869                 return FALSE;
2870             }
2871         }
2872       if (get_elf_i386_backend_data (output_bfd)->is_vxworks
2873           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2874         return FALSE;
2875     }
2876 #undef add_dynamic_entry
2877
2878   return TRUE;
2879 }
2880
2881 static bfd_boolean
2882 elf_i386_always_size_sections (bfd *output_bfd,
2883                                struct bfd_link_info *info)
2884 {
2885   asection *tls_sec = elf_hash_table (info)->tls_sec;
2886
2887   if (tls_sec)
2888     {
2889       struct elf_link_hash_entry *tlsbase;
2890
2891       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2892                                       "_TLS_MODULE_BASE_",
2893                                       FALSE, FALSE, FALSE);
2894
2895       if (tlsbase && tlsbase->type == STT_TLS)
2896         {
2897           struct elf_i386_link_hash_table *htab;
2898           struct bfd_link_hash_entry *bh = NULL;
2899           const struct elf_backend_data *bed
2900             = get_elf_backend_data (output_bfd);
2901
2902           htab = elf_i386_hash_table (info);
2903           if (htab == NULL)
2904             return FALSE;
2905
2906           if (!(_bfd_generic_link_add_one_symbol
2907                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2908                  tls_sec, 0, NULL, FALSE,
2909                  bed->collect, &bh)))
2910             return FALSE;
2911
2912           htab->tls_module_base = bh;
2913
2914           tlsbase = (struct elf_link_hash_entry *)bh;
2915           tlsbase->def_regular = 1;
2916           tlsbase->other = STV_HIDDEN;
2917           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2918         }
2919     }
2920
2921   return TRUE;
2922 }
2923
2924 /* Set the correct type for an x86 ELF section.  We do this by the
2925    section name, which is a hack, but ought to work.  */
2926
2927 static bfd_boolean
2928 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2929                         Elf_Internal_Shdr *hdr,
2930                         asection *sec)
2931 {
2932   const char *name;
2933
2934   name = bfd_get_section_name (abfd, sec);
2935
2936   /* This is an ugly, but unfortunately necessary hack that is
2937      needed when producing EFI binaries on x86. It tells
2938      elf.c:elf_fake_sections() not to consider ".reloc" as a section
2939      containing ELF relocation info.  We need this hack in order to
2940      be able to generate ELF binaries that can be translated into
2941      EFI applications (which are essentially COFF objects).  Those
2942      files contain a COFF ".reloc" section inside an ELFNN object,
2943      which would normally cause BFD to segfault because it would
2944      attempt to interpret this section as containing relocation
2945      entries for section "oc".  With this hack enabled, ".reloc"
2946      will be treated as a normal data section, which will avoid the
2947      segfault.  However, you won't be able to create an ELFNN binary
2948      with a section named "oc" that needs relocations, but that's
2949      the kind of ugly side-effects you get when detecting section
2950      types based on their names...  In practice, this limitation is
2951      unlikely to bite.  */
2952   if (strcmp (name, ".reloc") == 0)
2953     hdr->sh_type = SHT_PROGBITS;
2954
2955   return TRUE;
2956 }
2957
2958 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2959    executables.  Rather than setting it to the beginning of the TLS
2960    section, we have to set it to the end.    This function may be called
2961    multiple times, it is idempotent.  */
2962
2963 static void
2964 elf_i386_set_tls_module_base (struct bfd_link_info *info)
2965 {
2966   struct elf_i386_link_hash_table *htab;
2967   struct bfd_link_hash_entry *base;
2968
2969   if (!info->executable)
2970     return;
2971
2972   htab = elf_i386_hash_table (info);
2973   if (htab == NULL)
2974     return;
2975
2976   base = htab->tls_module_base;
2977   if (base == NULL)
2978     return;
2979
2980   base->u.def.value = htab->elf.tls_size;
2981 }
2982
2983 /* Return the base VMA address which should be subtracted from real addresses
2984    when resolving @dtpoff relocation.
2985    This is PT_TLS segment p_vaddr.  */
2986
2987 static bfd_vma
2988 elf_i386_dtpoff_base (struct bfd_link_info *info)
2989 {
2990   /* If tls_sec is NULL, we should have signalled an error already.  */
2991   if (elf_hash_table (info)->tls_sec == NULL)
2992     return 0;
2993   return elf_hash_table (info)->tls_sec->vma;
2994 }
2995
2996 /* Return the relocation value for @tpoff relocation
2997    if STT_TLS virtual address is ADDRESS.  */
2998
2999 static bfd_vma
3000 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3001 {
3002   struct elf_link_hash_table *htab = elf_hash_table (info);
3003   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3004   bfd_vma static_tls_size;
3005
3006   /* If tls_sec is NULL, we should have signalled an error already.  */
3007   if (htab->tls_sec == NULL)
3008     return 0;
3009
3010   /* Consider special static TLS alignment requirements.  */
3011   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3012   return static_tls_size + htab->tls_sec->vma - address;
3013 }
3014
3015 /* Relocate an i386 ELF section.  */
3016
3017 static bfd_boolean
3018 elf_i386_relocate_section (bfd *output_bfd,
3019                            struct bfd_link_info *info,
3020                            bfd *input_bfd,
3021                            asection *input_section,
3022                            bfd_byte *contents,
3023                            Elf_Internal_Rela *relocs,
3024                            Elf_Internal_Sym *local_syms,
3025                            asection **local_sections)
3026 {
3027   struct elf_i386_link_hash_table *htab;
3028   Elf_Internal_Shdr *symtab_hdr;
3029   struct elf_link_hash_entry **sym_hashes;
3030   bfd_vma *local_got_offsets;
3031   bfd_vma *local_tlsdesc_gotents;
3032   Elf_Internal_Rela *rel;
3033   Elf_Internal_Rela *relend;
3034   bfd_boolean is_vxworks_tls;
3035   unsigned plt_entry_size;
3036
3037   BFD_ASSERT (is_i386_elf (input_bfd));
3038
3039   htab = elf_i386_hash_table (info);
3040   if (htab == NULL)
3041     return FALSE;
3042   symtab_hdr = &elf_symtab_hdr (input_bfd);
3043   sym_hashes = elf_sym_hashes (input_bfd);
3044   local_got_offsets = elf_local_got_offsets (input_bfd);
3045   local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3046   /* We have to handle relocations in vxworks .tls_vars sections
3047      specially, because the dynamic loader is 'weird'.  */
3048   is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3049                     && info->shared
3050                     && !strcmp (input_section->output_section->name,
3051                                 ".tls_vars"));
3052
3053   elf_i386_set_tls_module_base (info);
3054
3055   plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3056
3057   rel = relocs;
3058   relend = relocs + input_section->reloc_count;
3059   for (; rel < relend; rel++)
3060     {
3061       unsigned int r_type;
3062       reloc_howto_type *howto;
3063       unsigned long r_symndx;
3064       struct elf_link_hash_entry *h;
3065       Elf_Internal_Sym *sym;
3066       asection *sec;
3067       bfd_vma off, offplt;
3068       bfd_vma relocation;
3069       bfd_boolean unresolved_reloc;
3070       bfd_reloc_status_type r;
3071       unsigned int indx;
3072       int tls_type;
3073
3074       r_type = ELF32_R_TYPE (rel->r_info);
3075       if (r_type == R_386_GNU_VTINHERIT
3076           || r_type == R_386_GNU_VTENTRY)
3077         continue;
3078
3079       if ((indx = r_type) >= R_386_standard
3080           && ((indx = r_type - R_386_ext_offset) - R_386_standard
3081               >= R_386_ext - R_386_standard)
3082           && ((indx = r_type - R_386_tls_offset) - R_386_ext
3083               >= R_386_irelative - R_386_ext))
3084         {
3085           (*_bfd_error_handler)
3086             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3087              input_bfd, input_section, r_type);
3088           bfd_set_error (bfd_error_bad_value);
3089           return FALSE;
3090         }
3091       howto = elf_howto_table + indx;
3092
3093       r_symndx = ELF32_R_SYM (rel->r_info);
3094       h = NULL;
3095       sym = NULL;
3096       sec = NULL;
3097       unresolved_reloc = FALSE;
3098       if (r_symndx < symtab_hdr->sh_info)
3099         {
3100           sym = local_syms + r_symndx;
3101           sec = local_sections[r_symndx];
3102           relocation = (sec->output_section->vma
3103                         + sec->output_offset
3104                         + sym->st_value);
3105
3106           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3107               && ((sec->flags & SEC_MERGE) != 0
3108                   || (info->relocatable
3109                       && sec->output_offset != 0)))
3110             {
3111               bfd_vma addend;
3112               bfd_byte *where = contents + rel->r_offset;
3113
3114               switch (howto->size)
3115                 {
3116                 case 0:
3117                   addend = bfd_get_8 (input_bfd, where);
3118                   if (howto->pc_relative)
3119                     {
3120                       addend = (addend ^ 0x80) - 0x80;
3121                       addend += 1;
3122                     }
3123                   break;
3124                 case 1:
3125                   addend = bfd_get_16 (input_bfd, where);
3126                   if (howto->pc_relative)
3127                     {
3128                       addend = (addend ^ 0x8000) - 0x8000;
3129                       addend += 2;
3130                     }
3131                   break;
3132                 case 2:
3133                   addend = bfd_get_32 (input_bfd, where);
3134                   if (howto->pc_relative)
3135                     {
3136                       addend = (addend ^ 0x80000000) - 0x80000000;
3137                       addend += 4;
3138                     }
3139                   break;
3140                 default:
3141                   abort ();
3142                 }
3143
3144               if (info->relocatable)
3145                 addend += sec->output_offset;
3146               else
3147                 {
3148                   asection *msec = sec;
3149                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3150                                                    addend);
3151                   addend -= relocation;
3152                   addend += msec->output_section->vma + msec->output_offset;
3153                 }
3154
3155               switch (howto->size)
3156                 {
3157                 case 0:
3158                   /* FIXME: overflow checks.  */
3159                   if (howto->pc_relative)
3160                     addend -= 1;
3161                   bfd_put_8 (input_bfd, addend, where);
3162                   break;
3163                 case 1:
3164                   if (howto->pc_relative)
3165                     addend -= 2;
3166                   bfd_put_16 (input_bfd, addend, where);
3167                   break;
3168                 case 2:
3169                   if (howto->pc_relative)
3170                     addend -= 4;
3171                   bfd_put_32 (input_bfd, addend, where);
3172                   break;
3173                 }
3174             }
3175           else if (!info->relocatable
3176                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3177             {
3178               /* Relocate against local STT_GNU_IFUNC symbol.  */
3179               h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3180                                                FALSE);
3181               if (h == NULL)
3182                 abort ();
3183
3184               /* Set STT_GNU_IFUNC symbol value.  */
3185               h->root.u.def.value = sym->st_value;
3186               h->root.u.def.section = sec;
3187             }
3188         }
3189       else
3190         {
3191           bfd_boolean warned ATTRIBUTE_UNUSED;
3192
3193           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3194                                    r_symndx, symtab_hdr, sym_hashes,
3195                                    h, sec, relocation,
3196                                    unresolved_reloc, warned);
3197         }
3198
3199       if (sec != NULL && elf_discarded_section (sec))
3200         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3201                                          rel, relend, howto, contents);
3202
3203       if (info->relocatable)
3204         continue;
3205
3206       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3207          it here if it is defined in a non-shared object.  */
3208       if (h != NULL
3209           && h->type == STT_GNU_IFUNC
3210           && h->def_regular)
3211         {
3212           asection *plt, *gotplt, *base_got;
3213           bfd_vma plt_index;
3214           const char *name;
3215
3216           if ((input_section->flags & SEC_ALLOC) == 0
3217               || h->plt.offset == (bfd_vma) -1)
3218             abort ();
3219
3220           /* STT_GNU_IFUNC symbol must go through PLT.  */
3221           if (htab->elf.splt != NULL)
3222             {
3223               plt = htab->elf.splt;
3224               gotplt = htab->elf.sgotplt;
3225             }
3226           else
3227             {
3228               plt = htab->elf.iplt;
3229               gotplt = htab->elf.igotplt;
3230             }
3231
3232           relocation = (plt->output_section->vma
3233                         + plt->output_offset + h->plt.offset);
3234
3235           switch (r_type)
3236             {
3237             default:
3238               if (h->root.root.string)
3239                 name = h->root.root.string;
3240               else
3241                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3242                                          NULL);
3243               (*_bfd_error_handler)
3244                 (_("%B: relocation %s against STT_GNU_IFUNC "
3245                    "symbol `%s' isn't handled by %s"), input_bfd,
3246                  elf_howto_table[r_type].name,
3247                  name, __FUNCTION__);
3248               bfd_set_error (bfd_error_bad_value);
3249               return FALSE;
3250
3251             case R_386_32:
3252               /* Generate dynamic relcoation only when there is a
3253                  non-GOT reference in a shared object.  */
3254               if (info->shared && h->non_got_ref)
3255                 {
3256                   Elf_Internal_Rela outrel;
3257                   bfd_byte *loc;
3258                   asection *sreloc;
3259                   bfd_vma offset;
3260                   bfd_boolean relocate;
3261
3262                   /* Need a dynamic relocation to get the real function
3263                      adddress.  */
3264                   offset = _bfd_elf_section_offset (output_bfd,
3265                                                     info,
3266                                                     input_section,
3267                                                     rel->r_offset);
3268                   if (offset == (bfd_vma) -1
3269                       || offset == (bfd_vma) -2)
3270                     abort ();
3271
3272                   outrel.r_offset = (input_section->output_section->vma
3273                                      + input_section->output_offset
3274                                      + offset);
3275
3276                   if (h->dynindx == -1
3277                       || h->forced_local
3278                       || info->executable)
3279                     {
3280                       /* This symbol is resolved locally.  */
3281                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3282                       relocate = TRUE;
3283                     }
3284                   else
3285                     {
3286                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3287                       relocate = FALSE;
3288                     }
3289
3290                   sreloc = htab->elf.irelifunc;
3291                   loc = sreloc->contents;
3292                   loc += (sreloc->reloc_count++
3293                           * sizeof (Elf32_External_Rel));
3294                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3295
3296                   /* If this reloc is against an external symbol, we
3297                      do not want to fiddle with the addend.  Otherwise,
3298                      we need to include the symbol value so that it
3299                      becomes an addend for the dynamic reloc.  For an
3300                      internal symbol, we have updated addend.  */
3301                   if (! relocate)
3302                     continue;
3303                 }
3304               /* FALLTHROUGH */
3305             case R_386_PC32:
3306             case R_386_PLT32:
3307               goto do_relocation;
3308
3309             case R_386_GOT32:
3310               base_got = htab->elf.sgot;
3311               off = h->got.offset;
3312
3313               if (base_got == NULL)
3314                 abort ();
3315
3316               if (off == (bfd_vma) -1)
3317                 {
3318                   /* We can't use h->got.offset here to save state, or
3319                      even just remember the offset, as finish_dynamic_symbol
3320                      would use that as offset into .got.  */
3321
3322                   if (htab->elf.splt != NULL)
3323                     {
3324                       plt_index = h->plt.offset / plt_entry_size - 1;
3325                       off = (plt_index + 3) * 4;
3326                       base_got = htab->elf.sgotplt;
3327                     }
3328                   else
3329                     {
3330                       plt_index = h->plt.offset / plt_entry_size;
3331                       off = plt_index * 4;
3332                       base_got = htab->elf.igotplt;
3333                     }
3334
3335                   if (h->dynindx == -1
3336                       || h->forced_local
3337                       || info->symbolic)
3338                     {
3339                       /* This references the local defitionion.  We must
3340                          initialize this entry in the global offset table.
3341                          Since the offset must always be a multiple of 8,
3342                          we use the least significant bit to record
3343                          whether we have initialized it already.
3344
3345                          When doing a dynamic link, we create a .rela.got
3346                          relocation entry to initialize the value.  This
3347                          is done in the finish_dynamic_symbol routine.   */
3348                       if ((off & 1) != 0)
3349                         off &= ~1;
3350                       else
3351                         {
3352                           bfd_put_32 (output_bfd, relocation,
3353                                       base_got->contents + off);
3354                           h->got.offset |= 1;
3355                         }
3356                     }
3357
3358                   relocation = off;
3359
3360                   /* Adjust for static executables.  */
3361                   if (htab->elf.splt == NULL)
3362                     relocation += gotplt->output_offset;
3363                 }
3364               else
3365                 {
3366                   relocation = (base_got->output_section->vma
3367                                 + base_got->output_offset + off
3368                                 - gotplt->output_section->vma
3369                                 - gotplt->output_offset);
3370                   /* Adjust for static executables.  */
3371                   if (htab->elf.splt == NULL)
3372                     relocation += gotplt->output_offset;
3373                 }
3374
3375               goto do_relocation;
3376
3377             case R_386_GOTOFF:
3378               relocation -= (gotplt->output_section->vma
3379                              + gotplt->output_offset);
3380               goto do_relocation;
3381             }
3382         }
3383
3384       switch (r_type)
3385         {
3386         case R_386_GOT32:
3387           /* Relocation is to the entry for this symbol in the global
3388              offset table.  */
3389           if (htab->elf.sgot == NULL)
3390             abort ();
3391
3392           if (h != NULL)
3393             {
3394               bfd_boolean dyn;
3395
3396               off = h->got.offset;
3397               dyn = htab->elf.dynamic_sections_created;
3398               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3399                   || (info->shared
3400                       && SYMBOL_REFERENCES_LOCAL (info, h))
3401                   || (ELF_ST_VISIBILITY (h->other)
3402                       && h->root.type == bfd_link_hash_undefweak))
3403                 {
3404                   /* This is actually a static link, or it is a
3405                      -Bsymbolic link and the symbol is defined
3406                      locally, or the symbol was forced to be local
3407                      because of a version file.  We must initialize
3408                      this entry in the global offset table.  Since the
3409                      offset must always be a multiple of 4, we use the
3410                      least significant bit to record whether we have
3411                      initialized it already.
3412
3413                      When doing a dynamic link, we create a .rel.got
3414                      relocation entry to initialize the value.  This
3415                      is done in the finish_dynamic_symbol routine.  */
3416                   if ((off & 1) != 0)
3417                     off &= ~1;
3418                   else
3419                     {
3420                       bfd_put_32 (output_bfd, relocation,
3421                                   htab->elf.sgot->contents + off);
3422                       h->got.offset |= 1;
3423                     }
3424                 }
3425               else
3426                 unresolved_reloc = FALSE;
3427             }
3428           else
3429             {
3430               if (local_got_offsets == NULL)
3431                 abort ();
3432
3433               off = local_got_offsets[r_symndx];
3434
3435               /* The offset must always be a multiple of 4.  We use
3436                  the least significant bit to record whether we have
3437                  already generated the necessary reloc.  */
3438               if ((off & 1) != 0)
3439                 off &= ~1;
3440               else
3441                 {
3442                   bfd_put_32 (output_bfd, relocation,
3443                               htab->elf.sgot->contents + off);
3444
3445                   if (info->shared)
3446                     {
3447                       asection *s;
3448                       Elf_Internal_Rela outrel;
3449                       bfd_byte *loc;
3450
3451                       s = htab->elf.srelgot;
3452                       if (s == NULL)
3453                         abort ();
3454
3455                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3456                                          + htab->elf.sgot->output_offset
3457                                          + off);
3458                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3459                       loc = s->contents;
3460                       loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
3461                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3462                     }
3463
3464                   local_got_offsets[r_symndx] |= 1;
3465                 }
3466             }
3467
3468           if (off >= (bfd_vma) -2)
3469             abort ();
3470
3471           relocation = htab->elf.sgot->output_section->vma
3472                        + htab->elf.sgot->output_offset + off
3473                        - htab->elf.sgotplt->output_section->vma
3474                        - htab->elf.sgotplt->output_offset;
3475           break;
3476
3477         case R_386_GOTOFF:
3478           /* Relocation is relative to the start of the global offset
3479              table.  */
3480
3481           /* Check to make sure it isn't a protected function symbol
3482              for shared library since it may not be local when used
3483              as function address.  We also need to make sure that a
3484              symbol is defined locally.  */
3485           if (info->shared && h)
3486             {
3487               if (!h->def_regular)
3488                 {
3489                   const char *v;
3490
3491                   switch (ELF_ST_VISIBILITY (h->other))
3492                     {
3493                     case STV_HIDDEN:
3494                       v = _("hidden symbol");
3495                       break;
3496                     case STV_INTERNAL:
3497                       v = _("internal symbol");
3498                       break;
3499                     case STV_PROTECTED:
3500                       v = _("protected symbol");
3501                       break;
3502                     default:
3503                       v = _("symbol");
3504                       break;
3505                     }
3506
3507                   (*_bfd_error_handler)
3508                     (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3509                      input_bfd, v, h->root.root.string);
3510                   bfd_set_error (bfd_error_bad_value);
3511                   return FALSE;
3512                 }
3513               else if (!info->executable
3514                        && h->type == STT_FUNC
3515                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3516                 {
3517                   (*_bfd_error_handler)
3518                     (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3519                      input_bfd, h->root.root.string);
3520                   bfd_set_error (bfd_error_bad_value);
3521                   return FALSE;
3522                 }
3523             }
3524
3525           /* Note that sgot is not involved in this
3526              calculation.  We always want the start of .got.plt.  If we
3527              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3528              permitted by the ABI, we might have to change this
3529              calculation.  */
3530           relocation -= htab->elf.sgotplt->output_section->vma
3531                         + htab->elf.sgotplt->output_offset;
3532           break;
3533
3534         case R_386_GOTPC:
3535           /* Use global offset table as symbol value.  */
3536           relocation = htab->elf.sgotplt->output_section->vma
3537                        + htab->elf.sgotplt->output_offset;
3538           unresolved_reloc = FALSE;
3539           break;
3540
3541         case R_386_PLT32:
3542           /* Relocation is to the entry for this symbol in the
3543              procedure linkage table.  */
3544
3545           /* Resolve a PLT32 reloc against a local symbol directly,
3546              without using the procedure linkage table.  */
3547           if (h == NULL)
3548             break;
3549
3550           if (h->plt.offset == (bfd_vma) -1
3551               || htab->elf.splt == NULL)
3552             {
3553               /* We didn't make a PLT entry for this symbol.  This
3554                  happens when statically linking PIC code, or when
3555                  using -Bsymbolic.  */
3556               break;
3557             }
3558
3559           relocation = (htab->elf.splt->output_section->vma
3560                         + htab->elf.splt->output_offset
3561                         + h->plt.offset);
3562           unresolved_reloc = FALSE;
3563           break;
3564
3565         case R_386_32:
3566         case R_386_PC32:
3567           if ((input_section->flags & SEC_ALLOC) == 0
3568               || is_vxworks_tls)
3569             break;
3570
3571           if ((info->shared
3572                && (h == NULL
3573                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3574                    || h->root.type != bfd_link_hash_undefweak)
3575                && (r_type != R_386_PC32
3576                    || !SYMBOL_CALLS_LOCAL (info, h)))
3577               || (ELIMINATE_COPY_RELOCS
3578                   && !info->shared
3579                   && h != NULL
3580                   && h->dynindx != -1
3581                   && !h->non_got_ref
3582                   && ((h->def_dynamic
3583                        && !h->def_regular)
3584                       || h->root.type == bfd_link_hash_undefweak
3585                       || h->root.type == bfd_link_hash_undefined)))
3586             {
3587               Elf_Internal_Rela outrel;
3588               bfd_byte *loc;
3589               bfd_boolean skip, relocate;
3590               asection *sreloc;
3591
3592               /* When generating a shared object, these relocations
3593                  are copied into the output file to be resolved at run
3594                  time.  */
3595
3596               skip = FALSE;
3597               relocate = FALSE;
3598
3599               outrel.r_offset =
3600                 _bfd_elf_section_offset (output_bfd, info, input_section,
3601                                          rel->r_offset);
3602               if (outrel.r_offset == (bfd_vma) -1)
3603                 skip = TRUE;
3604               else if (outrel.r_offset == (bfd_vma) -2)
3605                 skip = TRUE, relocate = TRUE;
3606               outrel.r_offset += (input_section->output_section->vma
3607                                   + input_section->output_offset);
3608
3609               if (skip)
3610                 memset (&outrel, 0, sizeof outrel);
3611               else if (h != NULL
3612                        && h->dynindx != -1
3613                        && (r_type == R_386_PC32
3614                            || !info->shared
3615                            || !SYMBOLIC_BIND (info, h)
3616                            || !h->def_regular))
3617                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3618               else
3619                 {
3620                   /* This symbol is local, or marked to become local.  */
3621                   relocate = TRUE;
3622                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3623                 }
3624
3625               sreloc = elf_section_data (input_section)->sreloc;
3626
3627               if (sreloc == NULL || sreloc->contents == NULL)
3628                 {
3629                   r = bfd_reloc_notsupported;
3630                   goto check_relocation_error;
3631                 }
3632
3633               loc = sreloc->contents;
3634               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3635
3636               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3637
3638               /* If this reloc is against an external symbol, we do
3639                  not want to fiddle with the addend.  Otherwise, we
3640                  need to include the symbol value so that it becomes
3641                  an addend for the dynamic reloc.  */
3642               if (! relocate)
3643                 continue;
3644             }
3645           break;
3646
3647         case R_386_TLS_IE:
3648           if (!info->executable)
3649             {
3650               Elf_Internal_Rela outrel;
3651               bfd_byte *loc;
3652               asection *sreloc;
3653
3654               outrel.r_offset = rel->r_offset
3655                                 + input_section->output_section->vma
3656                                 + input_section->output_offset;
3657               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3658               sreloc = elf_section_data (input_section)->sreloc;
3659               if (sreloc == NULL)
3660                 abort ();
3661               loc = sreloc->contents;
3662               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3663               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3664             }
3665           /* Fall through */
3666
3667         case R_386_TLS_GD:
3668         case R_386_TLS_GOTDESC:
3669         case R_386_TLS_DESC_CALL:
3670         case R_386_TLS_IE_32:
3671         case R_386_TLS_GOTIE:
3672           tls_type = GOT_UNKNOWN;
3673           if (h == NULL && local_got_offsets)
3674             tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3675           else if (h != NULL)
3676             tls_type = elf_i386_hash_entry(h)->tls_type;
3677           if (tls_type == GOT_TLS_IE)
3678             tls_type = GOT_TLS_IE_NEG;
3679
3680           if (! elf_i386_tls_transition (info, input_bfd,
3681                                          input_section, contents,
3682                                          symtab_hdr, sym_hashes,
3683                                          &r_type, tls_type, rel,
3684                                          relend, h, r_symndx))
3685             return FALSE;
3686
3687           if (r_type == R_386_TLS_LE_32)
3688             {
3689               BFD_ASSERT (! unresolved_reloc);
3690               if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3691                 {
3692                   unsigned int type;
3693                   bfd_vma roff;
3694
3695                   /* GD->LE transition.  */
3696                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3697                   if (type == 0x04)
3698                     {
3699                       /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3700                          Change it into:
3701                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3702                          (6 byte form of subl).  */
3703                       memcpy (contents + rel->r_offset - 3,
3704                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3705                       roff = rel->r_offset + 5;
3706                     }
3707                   else
3708                     {
3709                       /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3710                          Change it into:
3711                          movl %gs:0, %eax; subl $foo@tpoff, %eax
3712                          (6 byte form of subl).  */
3713                       memcpy (contents + rel->r_offset - 2,
3714                               "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3715                       roff = rel->r_offset + 6;
3716                     }
3717                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3718                               contents + roff);
3719                   /* Skip R_386_PC32/R_386_PLT32.  */
3720                   rel++;
3721                   continue;
3722                 }
3723               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3724                 {
3725                   /* GDesc -> LE transition.
3726                      It's originally something like:
3727                      leal x@tlsdesc(%ebx), %eax
3728
3729                      leal x@ntpoff, %eax
3730
3731                      Registers other than %eax may be set up here.  */
3732
3733                   unsigned int val;
3734                   bfd_vma roff;
3735
3736                   roff = rel->r_offset;
3737                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3738
3739                   /* Now modify the instruction as appropriate.  */
3740                   /* aoliva FIXME: remove the above and xor the byte
3741                      below with 0x86.  */
3742                   bfd_put_8 (output_bfd, val ^ 0x86,
3743                              contents + roff - 1);
3744                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3745                               contents + roff);
3746                   continue;
3747                 }
3748               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3749                 {
3750                   /* GDesc -> LE transition.
3751                      It's originally:
3752                      call *(%eax)
3753                      Turn it into:
3754                      xchg %ax,%ax  */
3755
3756                   bfd_vma roff;
3757
3758                   roff = rel->r_offset;
3759                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3760                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3761                   continue;
3762                 }
3763               else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
3764                 {
3765                   unsigned int val;
3766
3767                   /* IE->LE transition:
3768                      Originally it can be one of:
3769                      movl foo, %eax
3770                      movl foo, %reg
3771                      addl foo, %reg
3772                      We change it into:
3773                      movl $foo, %eax
3774                      movl $foo, %reg
3775                      addl $foo, %reg.  */
3776                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3777                   if (val == 0xa1)
3778                     {
3779                       /* movl foo, %eax.  */
3780                       bfd_put_8 (output_bfd, 0xb8,
3781                                  contents + rel->r_offset - 1);
3782                     }
3783                   else
3784                     {
3785                       unsigned int type;
3786
3787                       type = bfd_get_8 (input_bfd,
3788                                         contents + rel->r_offset - 2);
3789                       switch (type)
3790                         {
3791                         case 0x8b:
3792                           /* movl */
3793                           bfd_put_8 (output_bfd, 0xc7,
3794                                      contents + rel->r_offset - 2);
3795                           bfd_put_8 (output_bfd,
3796                                      0xc0 | ((val >> 3) & 7),
3797                                      contents + rel->r_offset - 1);
3798                           break;
3799                         case 0x03:
3800                           /* addl */
3801                           bfd_put_8 (output_bfd, 0x81,
3802                                      contents + rel->r_offset - 2);
3803                           bfd_put_8 (output_bfd,
3804                                      0xc0 | ((val >> 3) & 7),
3805                                      contents + rel->r_offset - 1);
3806                           break;
3807                         default:
3808                           BFD_FAIL ();
3809                           break;
3810                         }
3811                     }
3812                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3813                               contents + rel->r_offset);
3814                   continue;
3815                 }
3816               else
3817                 {
3818                   unsigned int val, type;
3819
3820                   /* {IE_32,GOTIE}->LE transition:
3821                      Originally it can be one of:
3822                      subl foo(%reg1), %reg2
3823                      movl foo(%reg1), %reg2
3824                      addl foo(%reg1), %reg2
3825                      We change it into:
3826                      subl $foo, %reg2
3827                      movl $foo, %reg2 (6 byte form)
3828                      addl $foo, %reg2.  */
3829                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3830                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3831                   if (type == 0x8b)
3832                     {
3833                       /* movl */
3834                       bfd_put_8 (output_bfd, 0xc7,
3835                                  contents + rel->r_offset - 2);
3836                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3837                                  contents + rel->r_offset - 1);
3838                     }
3839                   else if (type == 0x2b)
3840                     {
3841                       /* subl */
3842                       bfd_put_8 (output_bfd, 0x81,
3843                                  contents + rel->r_offset - 2);
3844                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3845                                  contents + rel->r_offset - 1);
3846                     }
3847                   else if (type == 0x03)
3848                     {
3849                       /* addl */
3850                       bfd_put_8 (output_bfd, 0x81,
3851                                  contents + rel->r_offset - 2);
3852                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3853                                  contents + rel->r_offset - 1);
3854                     }
3855                   else
3856                     BFD_FAIL ();
3857                   if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3858                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3859                                 contents + rel->r_offset);
3860                   else
3861                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3862                                 contents + rel->r_offset);
3863                   continue;
3864                 }
3865             }
3866
3867           if (htab->elf.sgot == NULL)
3868             abort ();
3869
3870           if (h != NULL)
3871             {
3872               off = h->got.offset;
3873               offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3874             }
3875           else
3876             {
3877               if (local_got_offsets == NULL)
3878                 abort ();
3879
3880               off = local_got_offsets[r_symndx];
3881               offplt = local_tlsdesc_gotents[r_symndx];
3882             }
3883
3884           if ((off & 1) != 0)
3885             off &= ~1;
3886           else
3887             {
3888               Elf_Internal_Rela outrel;
3889               bfd_byte *loc;
3890               int dr_type;
3891               asection *sreloc;