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