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