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