1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 Free Software Foundation, Inc.
5 Contributed by Jan Hubicka <jh@suse.cz>.
7 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
30 #include "bfd_stdint.h"
34 #include "libiberty.h"
36 #include "elf/x86-64.h"
43 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
44 #define MINUS_ONE (~ (bfd_vma) 0)
46 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
47 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
48 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
49 since they are the same. */
51 #define ABI_64_P(abfd) \
52 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
54 /* The relocation "howto" table. Order of fields:
55 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
56 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
57 static reloc_howto_type x86_64_elf_howto_table
[] =
59 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
60 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
62 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
65 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
66 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
68 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
69 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
71 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
72 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
74 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
75 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
77 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
78 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
80 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
81 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
83 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
86 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
87 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
89 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
90 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
92 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
93 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
95 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
97 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
99 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
100 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
101 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
102 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
103 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
104 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
106 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
107 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
109 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
112 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
113 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
115 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
116 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
118 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
119 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
121 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
122 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
124 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
125 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
127 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
128 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
130 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
131 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
132 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
133 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
134 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
135 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
136 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
137 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
139 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
140 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
142 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
143 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
144 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
145 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
146 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
148 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
149 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
151 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
152 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
154 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
155 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
157 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
158 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
159 "R_X86_64_GOTPC32_TLSDESC",
160 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
161 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
162 complain_overflow_dont
, bfd_elf_generic_reloc
,
163 "R_X86_64_TLSDESC_CALL",
165 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
166 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
168 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
169 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
170 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
172 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
173 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
176 /* We have a gap in the reloc numbers here.
177 R_X86_64_standard counts the number up to this point, and
178 R_X86_64_vt_offset is the value to subtract from a reloc type of
179 R_X86_64_GNU_VT* to form an index into this table. */
180 #define R_X86_64_standard (R_X86_64_RELATIVE64 + 1)
181 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
183 /* GNU extension to record C++ vtable hierarchy. */
184 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
185 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
187 /* GNU extension to record C++ vtable member usage. */
188 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
189 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
192 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
193 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
194 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
198 #define IS_X86_64_PCREL_TYPE(TYPE) \
199 ( ((TYPE) == R_X86_64_PC8) \
200 || ((TYPE) == R_X86_64_PC16) \
201 || ((TYPE) == R_X86_64_PC32) \
202 || ((TYPE) == R_X86_64_PC64))
204 /* Map BFD relocs to the x86_64 elf relocs. */
207 bfd_reloc_code_real_type bfd_reloc_val
;
208 unsigned char elf_reloc_val
;
211 static const struct elf_reloc_map x86_64_reloc_map
[] =
213 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
214 { BFD_RELOC_64
, R_X86_64_64
, },
215 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
216 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
217 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
218 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
219 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
220 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
221 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
222 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
223 { BFD_RELOC_32
, R_X86_64_32
, },
224 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
225 { BFD_RELOC_16
, R_X86_64_16
, },
226 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
227 { BFD_RELOC_8
, R_X86_64_8
, },
228 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
229 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
230 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
231 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
232 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
233 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
234 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
235 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
236 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
237 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
238 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
239 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
240 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
241 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
242 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
243 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
244 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
245 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
246 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
247 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
248 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
249 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
250 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
251 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
252 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
255 static reloc_howto_type
*
256 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
260 if (r_type
== (unsigned int) R_X86_64_32
)
265 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
267 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
268 || r_type
>= (unsigned int) R_X86_64_max
)
270 if (r_type
>= (unsigned int) R_X86_64_standard
)
272 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
274 r_type
= R_X86_64_NONE
;
279 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
280 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
281 return &x86_64_elf_howto_table
[i
];
284 /* Given a BFD reloc type, return a HOWTO structure. */
285 static reloc_howto_type
*
286 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
287 bfd_reloc_code_real_type code
)
291 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
294 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
295 return elf_x86_64_rtype_to_howto (abfd
,
296 x86_64_reloc_map
[i
].elf_reloc_val
);
301 static reloc_howto_type
*
302 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
307 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
309 /* Get x32 R_X86_64_32. */
310 reloc_howto_type
*reloc
311 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
312 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
316 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
317 if (x86_64_elf_howto_table
[i
].name
!= NULL
318 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
319 return &x86_64_elf_howto_table
[i
];
324 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
327 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
328 Elf_Internal_Rela
*dst
)
332 r_type
= ELF32_R_TYPE (dst
->r_info
);
333 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
334 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
337 /* Support for core dump NOTE sections. */
339 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
344 switch (note
->descsz
)
349 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
351 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
354 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
362 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
364 elf_tdata (abfd
)->core
->signal
365 = bfd_get_16 (abfd
, note
->descdata
+ 12);
368 elf_tdata (abfd
)->core
->lwpid
369 = bfd_get_32 (abfd
, note
->descdata
+ 32);
378 /* Make a ".reg/999" section. */
379 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
380 size
, note
->descpos
+ offset
);
384 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
386 switch (note
->descsz
)
391 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
392 elf_tdata (abfd
)->core
->pid
393 = bfd_get_32 (abfd
, note
->descdata
+ 12);
394 elf_tdata (abfd
)->core
->program
395 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
396 elf_tdata (abfd
)->core
->command
397 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
400 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
401 elf_tdata (abfd
)->core
->pid
402 = bfd_get_32 (abfd
, note
->descdata
+ 24);
403 elf_tdata (abfd
)->core
->program
404 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
405 elf_tdata (abfd
)->core
->command
406 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
409 /* Note that for some reason, a spurious space is tacked
410 onto the end of the args in some (at least one anyway)
411 implementations, so strip it off if it exists. */
414 char *command
= elf_tdata (abfd
)->core
->command
;
415 int n
= strlen (command
);
417 if (0 < n
&& command
[n
- 1] == ' ')
418 command
[n
- 1] = '\0';
426 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
429 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
431 const char *fname
, *psargs
;
442 va_start (ap
, note_type
);
443 fname
= va_arg (ap
, const char *);
444 psargs
= va_arg (ap
, const char *);
447 if (bed
->s
->elfclass
== ELFCLASS32
)
450 memset (&data
, 0, sizeof (data
));
451 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
452 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
453 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
454 &data
, sizeof (data
));
459 memset (&data
, 0, sizeof (data
));
460 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
461 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
462 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
463 &data
, sizeof (data
));
468 va_start (ap
, note_type
);
469 pid
= va_arg (ap
, long);
470 cursig
= va_arg (ap
, int);
471 gregs
= va_arg (ap
, const void *);
474 if (bed
->s
->elfclass
== ELFCLASS32
)
476 if (bed
->elf_machine_code
== EM_X86_64
)
478 prstatusx32_t prstat
;
479 memset (&prstat
, 0, sizeof (prstat
));
481 prstat
.pr_cursig
= cursig
;
482 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
483 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
484 &prstat
, sizeof (prstat
));
489 memset (&prstat
, 0, sizeof (prstat
));
491 prstat
.pr_cursig
= cursig
;
492 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
493 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
494 &prstat
, sizeof (prstat
));
500 memset (&prstat
, 0, sizeof (prstat
));
502 prstat
.pr_cursig
= cursig
;
503 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
504 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
505 &prstat
, sizeof (prstat
));
512 /* Functions for the x86-64 ELF linker. */
514 /* The name of the dynamic interpreter. This is put in the .interp
517 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
518 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
520 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
521 copying dynamic variables from a shared lib into an app's dynbss
522 section, and instead use a dynamic relocation to point into the
524 #define ELIMINATE_COPY_RELOCS 1
526 /* The size in bytes of an entry in the global offset table. */
528 #define GOT_ENTRY_SIZE 8
530 /* The size in bytes of an entry in the procedure linkage table. */
532 #define PLT_ENTRY_SIZE 16
534 /* The first entry in a procedure linkage table looks like this. See the
535 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
537 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
539 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
540 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
541 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
544 /* Subsequent entries in a procedure linkage table look like this. */
546 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
548 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
549 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
550 0x68, /* pushq immediate */
551 0, 0, 0, 0, /* replaced with index into relocation table. */
552 0xe9, /* jmp relative */
553 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
556 /* .eh_frame covering the .plt section. */
558 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
560 #define PLT_CIE_LENGTH 20
561 #define PLT_FDE_LENGTH 36
562 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
563 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
564 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
565 0, 0, 0, 0, /* CIE ID */
567 'z', 'R', 0, /* Augmentation string */
568 1, /* Code alignment factor */
569 0x78, /* Data alignment factor */
570 16, /* Return address column */
571 1, /* Augmentation size */
572 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
573 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
574 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
575 DW_CFA_nop
, DW_CFA_nop
,
577 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
578 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
579 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
580 0, 0, 0, 0, /* .plt size goes here */
581 0, /* Augmentation size */
582 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
583 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
584 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
585 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
586 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
587 11, /* Block length */
588 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
589 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
590 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
591 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
592 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
595 /* Architecture-specific backend data for x86-64. */
597 struct elf_x86_64_backend_data
599 /* Templates for the initial PLT entry and for subsequent entries. */
600 const bfd_byte
*plt0_entry
;
601 const bfd_byte
*plt_entry
;
602 unsigned int plt_entry_size
; /* Size of each PLT entry. */
604 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
605 unsigned int plt0_got1_offset
;
606 unsigned int plt0_got2_offset
;
608 /* Offset of the end of the PC-relative instruction containing
610 unsigned int plt0_got2_insn_end
;
612 /* Offsets into plt_entry that are to be replaced with... */
613 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
614 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
615 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
617 /* Length of the PC-relative instruction containing plt_got_offset. */
618 unsigned int plt_got_insn_size
;
620 /* Offset of the end of the PC-relative jump to plt0_entry. */
621 unsigned int plt_plt_insn_end
;
623 /* Offset into plt_entry where the initial value of the GOT entry points. */
624 unsigned int plt_lazy_offset
;
626 /* .eh_frame covering the .plt section. */
627 const bfd_byte
*eh_frame_plt
;
628 unsigned int eh_frame_plt_size
;
631 #define get_elf_x86_64_backend_data(abfd) \
632 ((const struct elf_x86_64_backend_data *) \
633 get_elf_backend_data (abfd)->arch_data)
635 #define GET_PLT_ENTRY_SIZE(abfd) \
636 get_elf_x86_64_backend_data (abfd)->plt_entry_size
638 /* These are the standard parameters. */
639 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
641 elf_x86_64_plt0_entry
, /* plt0_entry */
642 elf_x86_64_plt_entry
, /* plt_entry */
643 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
644 2, /* plt0_got1_offset */
645 8, /* plt0_got2_offset */
646 12, /* plt0_got2_insn_end */
647 2, /* plt_got_offset */
648 7, /* plt_reloc_offset */
649 12, /* plt_plt_offset */
650 6, /* plt_got_insn_size */
651 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
652 6, /* plt_lazy_offset */
653 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
654 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
657 #define elf_backend_arch_data &elf_x86_64_arch_bed
659 /* x86-64 ELF linker hash entry. */
661 struct elf_x86_64_link_hash_entry
663 struct elf_link_hash_entry elf
;
665 /* Track dynamic relocs copied for this symbol. */
666 struct elf_dyn_relocs
*dyn_relocs
;
668 #define GOT_UNKNOWN 0
672 #define GOT_TLS_GDESC 4
673 #define GOT_TLS_GD_BOTH_P(type) \
674 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
675 #define GOT_TLS_GD_P(type) \
676 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
677 #define GOT_TLS_GDESC_P(type) \
678 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
679 #define GOT_TLS_GD_ANY_P(type) \
680 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
681 unsigned char tls_type
;
683 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
684 starting at the end of the jump table. */
688 #define elf_x86_64_hash_entry(ent) \
689 ((struct elf_x86_64_link_hash_entry *)(ent))
691 struct elf_x86_64_obj_tdata
693 struct elf_obj_tdata root
;
695 /* tls_type for each local got entry. */
696 char *local_got_tls_type
;
698 /* GOTPLT entries for TLS descriptors. */
699 bfd_vma
*local_tlsdesc_gotent
;
702 #define elf_x86_64_tdata(abfd) \
703 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
705 #define elf_x86_64_local_got_tls_type(abfd) \
706 (elf_x86_64_tdata (abfd)->local_got_tls_type)
708 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
709 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
711 #define is_x86_64_elf(bfd) \
712 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
713 && elf_tdata (bfd) != NULL \
714 && elf_object_id (bfd) == X86_64_ELF_DATA)
717 elf_x86_64_mkobject (bfd
*abfd
)
719 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
723 /* x86-64 ELF linker hash table. */
725 struct elf_x86_64_link_hash_table
727 struct elf_link_hash_table elf
;
729 /* Short-cuts to get to dynamic linker sections. */
732 asection
*plt_eh_frame
;
736 bfd_signed_vma refcount
;
740 /* The amount of space used by the jump slots in the GOT. */
741 bfd_vma sgotplt_jump_table_size
;
743 /* Small local sym cache. */
744 struct sym_cache sym_cache
;
746 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
747 bfd_vma (*r_sym
) (bfd_vma
);
748 unsigned int pointer_r_type
;
749 const char *dynamic_interpreter
;
750 int dynamic_interpreter_size
;
752 /* _TLS_MODULE_BASE_ symbol. */
753 struct bfd_link_hash_entry
*tls_module_base
;
755 /* Used by local STT_GNU_IFUNC symbols. */
756 htab_t loc_hash_table
;
757 void * loc_hash_memory
;
759 /* The offset into splt of the PLT entry for the TLS descriptor
760 resolver. Special values are 0, if not necessary (or not found
761 to be necessary yet), and -1 if needed but not determined
764 /* The offset into sgot of the GOT entry used by the PLT entry
768 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
769 bfd_vma next_jump_slot_index
;
770 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
771 bfd_vma next_irelative_index
;
774 /* Get the x86-64 ELF linker hash table from a link_info structure. */
776 #define elf_x86_64_hash_table(p) \
777 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
778 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
780 #define elf_x86_64_compute_jump_table_size(htab) \
781 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
783 /* Create an entry in an x86-64 ELF linker hash table. */
785 static struct bfd_hash_entry
*
786 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
787 struct bfd_hash_table
*table
,
790 /* Allocate the structure if it has not already been allocated by a
794 entry
= (struct bfd_hash_entry
*)
795 bfd_hash_allocate (table
,
796 sizeof (struct elf_x86_64_link_hash_entry
));
801 /* Call the allocation method of the superclass. */
802 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
805 struct elf_x86_64_link_hash_entry
*eh
;
807 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
808 eh
->dyn_relocs
= NULL
;
809 eh
->tls_type
= GOT_UNKNOWN
;
810 eh
->tlsdesc_got
= (bfd_vma
) -1;
816 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
817 for local symbol so that we can handle local STT_GNU_IFUNC symbols
818 as global symbol. We reuse indx and dynstr_index for local symbol
819 hash since they aren't used by global symbols in this backend. */
822 elf_x86_64_local_htab_hash (const void *ptr
)
824 struct elf_link_hash_entry
*h
825 = (struct elf_link_hash_entry
*) ptr
;
826 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
829 /* Compare local hash entries. */
832 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
834 struct elf_link_hash_entry
*h1
835 = (struct elf_link_hash_entry
*) ptr1
;
836 struct elf_link_hash_entry
*h2
837 = (struct elf_link_hash_entry
*) ptr2
;
839 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
842 /* Find and/or create a hash entry for local symbol. */
844 static struct elf_link_hash_entry
*
845 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
846 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
849 struct elf_x86_64_link_hash_entry e
, *ret
;
850 asection
*sec
= abfd
->sections
;
851 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
852 htab
->r_sym (rel
->r_info
));
855 e
.elf
.indx
= sec
->id
;
856 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
857 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
858 create
? INSERT
: NO_INSERT
);
865 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
869 ret
= (struct elf_x86_64_link_hash_entry
*)
870 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
871 sizeof (struct elf_x86_64_link_hash_entry
));
874 memset (ret
, 0, sizeof (*ret
));
875 ret
->elf
.indx
= sec
->id
;
876 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
877 ret
->elf
.dynindx
= -1;
883 /* Create an X86-64 ELF linker hash table. */
885 static struct bfd_link_hash_table
*
886 elf_x86_64_link_hash_table_create (bfd
*abfd
)
888 struct elf_x86_64_link_hash_table
*ret
;
889 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
891 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
895 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
896 elf_x86_64_link_hash_newfunc
,
897 sizeof (struct elf_x86_64_link_hash_entry
),
906 ret
->r_info
= elf64_r_info
;
907 ret
->r_sym
= elf64_r_sym
;
908 ret
->pointer_r_type
= R_X86_64_64
;
909 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
910 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
914 ret
->r_info
= elf32_r_info
;
915 ret
->r_sym
= elf32_r_sym
;
916 ret
->pointer_r_type
= R_X86_64_32
;
917 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
918 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
921 ret
->loc_hash_table
= htab_try_create (1024,
922 elf_x86_64_local_htab_hash
,
923 elf_x86_64_local_htab_eq
,
925 ret
->loc_hash_memory
= objalloc_create ();
926 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
932 return &ret
->elf
.root
;
935 /* Destroy an X86-64 ELF linker hash table. */
938 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
940 struct elf_x86_64_link_hash_table
*htab
941 = (struct elf_x86_64_link_hash_table
*) hash
;
943 if (htab
->loc_hash_table
)
944 htab_delete (htab
->loc_hash_table
);
945 if (htab
->loc_hash_memory
)
946 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
947 _bfd_elf_link_hash_table_free (hash
);
950 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
951 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
955 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
956 struct bfd_link_info
*info
)
958 struct elf_x86_64_link_hash_table
*htab
;
960 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
963 htab
= elf_x86_64_hash_table (info
);
967 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
969 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
972 || (!info
->shared
&& !htab
->srelbss
))
975 if (!info
->no_ld_generated_unwind_info
976 && htab
->plt_eh_frame
== NULL
977 && htab
->elf
.splt
!= NULL
)
979 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
980 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
981 | SEC_LINKER_CREATED
);
983 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
984 if (htab
->plt_eh_frame
== NULL
985 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
991 /* Copy the extra info we tack onto an elf_link_hash_entry. */
994 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
995 struct elf_link_hash_entry
*dir
,
996 struct elf_link_hash_entry
*ind
)
998 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1000 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1001 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1003 if (eind
->dyn_relocs
!= NULL
)
1005 if (edir
->dyn_relocs
!= NULL
)
1007 struct elf_dyn_relocs
**pp
;
1008 struct elf_dyn_relocs
*p
;
1010 /* Add reloc counts against the indirect sym to the direct sym
1011 list. Merge any entries against the same section. */
1012 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1014 struct elf_dyn_relocs
*q
;
1016 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1017 if (q
->sec
== p
->sec
)
1019 q
->pc_count
+= p
->pc_count
;
1020 q
->count
+= p
->count
;
1027 *pp
= edir
->dyn_relocs
;
1030 edir
->dyn_relocs
= eind
->dyn_relocs
;
1031 eind
->dyn_relocs
= NULL
;
1034 if (ind
->root
.type
== bfd_link_hash_indirect
1035 && dir
->got
.refcount
<= 0)
1037 edir
->tls_type
= eind
->tls_type
;
1038 eind
->tls_type
= GOT_UNKNOWN
;
1041 if (ELIMINATE_COPY_RELOCS
1042 && ind
->root
.type
!= bfd_link_hash_indirect
1043 && dir
->dynamic_adjusted
)
1045 /* If called to transfer flags for a weakdef during processing
1046 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1047 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1048 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1049 dir
->ref_regular
|= ind
->ref_regular
;
1050 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1051 dir
->needs_plt
|= ind
->needs_plt
;
1052 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1055 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1059 elf64_x86_64_elf_object_p (bfd
*abfd
)
1061 /* Set the right machine number for an x86-64 elf64 file. */
1062 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1067 elf32_x86_64_elf_object_p (bfd
*abfd
)
1069 /* Set the right machine number for an x86-64 elf32 file. */
1070 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1074 /* Return TRUE if the TLS access code sequence support transition
1078 elf_x86_64_check_tls_transition (bfd
*abfd
,
1079 struct bfd_link_info
*info
,
1082 Elf_Internal_Shdr
*symtab_hdr
,
1083 struct elf_link_hash_entry
**sym_hashes
,
1084 unsigned int r_type
,
1085 const Elf_Internal_Rela
*rel
,
1086 const Elf_Internal_Rela
*relend
)
1089 unsigned long r_symndx
;
1090 struct elf_link_hash_entry
*h
;
1092 struct elf_x86_64_link_hash_table
*htab
;
1094 /* Get the section contents. */
1095 if (contents
== NULL
)
1097 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1098 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1101 /* FIXME: How to better handle error condition? */
1102 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1105 /* Cache the section contents for elf_link_input_bfd. */
1106 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1110 htab
= elf_x86_64_hash_table (info
);
1111 offset
= rel
->r_offset
;
1114 case R_X86_64_TLSGD
:
1115 case R_X86_64_TLSLD
:
1116 if ((rel
+ 1) >= relend
)
1119 if (r_type
== R_X86_64_TLSGD
)
1121 /* Check transition from GD access model. For 64bit, only
1122 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1123 .word 0x6666; rex64; call __tls_get_addr
1124 can transit to different access model. For 32bit, only
1125 leaq foo@tlsgd(%rip), %rdi
1126 .word 0x6666; rex64; call __tls_get_addr
1127 can transit to different access model. */
1129 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1130 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1132 if ((offset
+ 12) > sec
->size
1133 || memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1136 if (ABI_64_P (abfd
))
1139 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1145 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1151 /* Check transition from LD access model. Only
1152 leaq foo@tlsld(%rip), %rdi;
1154 can transit to different access model. */
1156 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1158 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1161 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0
1162 || 0xe8 != *(contents
+ offset
+ 4))
1166 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1167 if (r_symndx
< symtab_hdr
->sh_info
)
1170 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1171 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1172 may be versioned. */
1174 && h
->root
.root
.string
!= NULL
1175 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1176 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
1177 && (strncmp (h
->root
.root
.string
,
1178 "__tls_get_addr", 14) == 0));
1180 case R_X86_64_GOTTPOFF
:
1181 /* Check transition from IE access model:
1182 mov foo@gottpoff(%rip), %reg
1183 add foo@gottpoff(%rip), %reg
1186 /* Check REX prefix first. */
1187 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1189 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1190 if (val
!= 0x48 && val
!= 0x4c)
1192 /* X32 may have 0x44 REX prefix or no REX prefix. */
1193 if (ABI_64_P (abfd
))
1199 /* X32 may not have any REX prefix. */
1200 if (ABI_64_P (abfd
))
1202 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1206 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1207 if (val
!= 0x8b && val
!= 0x03)
1210 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1211 return (val
& 0xc7) == 5;
1213 case R_X86_64_GOTPC32_TLSDESC
:
1214 /* Check transition from GDesc access model:
1215 leaq x@tlsdesc(%rip), %rax
1217 Make sure it's a leaq adding rip to a 32-bit offset
1218 into any register, although it's probably almost always
1221 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1224 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1225 if ((val
& 0xfb) != 0x48)
1228 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1231 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1232 return (val
& 0xc7) == 0x05;
1234 case R_X86_64_TLSDESC_CALL
:
1235 /* Check transition from GDesc access model:
1236 call *x@tlsdesc(%rax)
1238 if (offset
+ 2 <= sec
->size
)
1240 /* Make sure that it's a call *x@tlsdesc(%rax). */
1241 static const unsigned char call
[] = { 0xff, 0x10 };
1242 return memcmp (contents
+ offset
, call
, 2) == 0;
1252 /* Return TRUE if the TLS access transition is OK or no transition
1253 will be performed. Update R_TYPE if there is a transition. */
1256 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1257 asection
*sec
, bfd_byte
*contents
,
1258 Elf_Internal_Shdr
*symtab_hdr
,
1259 struct elf_link_hash_entry
**sym_hashes
,
1260 unsigned int *r_type
, int tls_type
,
1261 const Elf_Internal_Rela
*rel
,
1262 const Elf_Internal_Rela
*relend
,
1263 struct elf_link_hash_entry
*h
,
1264 unsigned long r_symndx
)
1266 unsigned int from_type
= *r_type
;
1267 unsigned int to_type
= from_type
;
1268 bfd_boolean check
= TRUE
;
1270 /* Skip TLS transition for functions. */
1272 && (h
->type
== STT_FUNC
1273 || h
->type
== STT_GNU_IFUNC
))
1278 case R_X86_64_TLSGD
:
1279 case R_X86_64_GOTPC32_TLSDESC
:
1280 case R_X86_64_TLSDESC_CALL
:
1281 case R_X86_64_GOTTPOFF
:
1282 if (info
->executable
)
1285 to_type
= R_X86_64_TPOFF32
;
1287 to_type
= R_X86_64_GOTTPOFF
;
1290 /* When we are called from elf_x86_64_relocate_section,
1291 CONTENTS isn't NULL and there may be additional transitions
1292 based on TLS_TYPE. */
1293 if (contents
!= NULL
)
1295 unsigned int new_to_type
= to_type
;
1297 if (info
->executable
1300 && tls_type
== GOT_TLS_IE
)
1301 new_to_type
= R_X86_64_TPOFF32
;
1303 if (to_type
== R_X86_64_TLSGD
1304 || to_type
== R_X86_64_GOTPC32_TLSDESC
1305 || to_type
== R_X86_64_TLSDESC_CALL
)
1307 if (tls_type
== GOT_TLS_IE
)
1308 new_to_type
= R_X86_64_GOTTPOFF
;
1311 /* We checked the transition before when we were called from
1312 elf_x86_64_check_relocs. We only want to check the new
1313 transition which hasn't been checked before. */
1314 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1315 to_type
= new_to_type
;
1320 case R_X86_64_TLSLD
:
1321 if (info
->executable
)
1322 to_type
= R_X86_64_TPOFF32
;
1329 /* Return TRUE if there is no transition. */
1330 if (from_type
== to_type
)
1333 /* Check if the transition can be performed. */
1335 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1336 symtab_hdr
, sym_hashes
,
1337 from_type
, rel
, relend
))
1339 reloc_howto_type
*from
, *to
;
1342 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1343 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1346 name
= h
->root
.root
.string
;
1349 struct elf_x86_64_link_hash_table
*htab
;
1351 htab
= elf_x86_64_hash_table (info
);
1356 Elf_Internal_Sym
*isym
;
1358 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1360 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1364 (*_bfd_error_handler
)
1365 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1366 "in section `%A' failed"),
1367 abfd
, sec
, from
->name
, to
->name
, name
,
1368 (unsigned long) rel
->r_offset
);
1369 bfd_set_error (bfd_error_bad_value
);
1377 /* Look through the relocs for a section during the first phase, and
1378 calculate needed space in the global offset table, procedure
1379 linkage table, and dynamic reloc sections. */
1382 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1384 const Elf_Internal_Rela
*relocs
)
1386 struct elf_x86_64_link_hash_table
*htab
;
1387 Elf_Internal_Shdr
*symtab_hdr
;
1388 struct elf_link_hash_entry
**sym_hashes
;
1389 const Elf_Internal_Rela
*rel
;
1390 const Elf_Internal_Rela
*rel_end
;
1393 if (info
->relocatable
)
1396 BFD_ASSERT (is_x86_64_elf (abfd
));
1398 htab
= elf_x86_64_hash_table (info
);
1402 symtab_hdr
= &elf_symtab_hdr (abfd
);
1403 sym_hashes
= elf_sym_hashes (abfd
);
1407 rel_end
= relocs
+ sec
->reloc_count
;
1408 for (rel
= relocs
; rel
< rel_end
; rel
++)
1410 unsigned int r_type
;
1411 unsigned long r_symndx
;
1412 struct elf_link_hash_entry
*h
;
1413 Elf_Internal_Sym
*isym
;
1415 bfd_boolean size_reloc
;
1417 r_symndx
= htab
->r_sym (rel
->r_info
);
1418 r_type
= ELF32_R_TYPE (rel
->r_info
);
1420 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1422 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1427 if (r_symndx
< symtab_hdr
->sh_info
)
1429 /* A local symbol. */
1430 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1435 /* Check relocation against local STT_GNU_IFUNC symbol. */
1436 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1438 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1443 /* Fake a STT_GNU_IFUNC symbol. */
1444 h
->type
= STT_GNU_IFUNC
;
1447 h
->forced_local
= 1;
1448 h
->root
.type
= bfd_link_hash_defined
;
1456 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1457 while (h
->root
.type
== bfd_link_hash_indirect
1458 || h
->root
.type
== bfd_link_hash_warning
)
1459 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1462 /* Check invalid x32 relocations. */
1463 if (!ABI_64_P (abfd
))
1469 case R_X86_64_DTPOFF64
:
1470 case R_X86_64_TPOFF64
:
1472 case R_X86_64_GOTOFF64
:
1473 case R_X86_64_GOT64
:
1474 case R_X86_64_GOTPCREL64
:
1475 case R_X86_64_GOTPC64
:
1476 case R_X86_64_GOTPLT64
:
1477 case R_X86_64_PLTOFF64
:
1480 name
= h
->root
.root
.string
;
1482 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1484 (*_bfd_error_handler
)
1485 (_("%B: relocation %s against symbol `%s' isn't "
1486 "supported in x32 mode"), abfd
,
1487 x86_64_elf_howto_table
[r_type
].name
, name
);
1488 bfd_set_error (bfd_error_bad_value
);
1496 /* Create the ifunc sections for static executables. If we
1497 never see an indirect function symbol nor we are building
1498 a static executable, those sections will be empty and
1499 won't appear in output. */
1510 case R_X86_64_PLT32
:
1511 case R_X86_64_GOTPCREL
:
1512 case R_X86_64_GOTPCREL64
:
1513 if (htab
->elf
.dynobj
== NULL
)
1514 htab
->elf
.dynobj
= abfd
;
1515 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1520 /* It is referenced by a non-shared object. */
1522 h
->root
.non_ir_ref
= 1;
1525 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1526 symtab_hdr
, sym_hashes
,
1527 &r_type
, GOT_UNKNOWN
,
1528 rel
, rel_end
, h
, r_symndx
))
1533 case R_X86_64_TLSLD
:
1534 htab
->tls_ld_got
.refcount
+= 1;
1537 case R_X86_64_TPOFF32
:
1538 if (!info
->executable
&& ABI_64_P (abfd
))
1541 name
= h
->root
.root
.string
;
1543 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1545 (*_bfd_error_handler
)
1546 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1548 x86_64_elf_howto_table
[r_type
].name
, name
);
1549 bfd_set_error (bfd_error_bad_value
);
1554 case R_X86_64_GOTTPOFF
:
1555 if (!info
->executable
)
1556 info
->flags
|= DF_STATIC_TLS
;
1559 case R_X86_64_GOT32
:
1560 case R_X86_64_GOTPCREL
:
1561 case R_X86_64_TLSGD
:
1562 case R_X86_64_GOT64
:
1563 case R_X86_64_GOTPCREL64
:
1564 case R_X86_64_GOTPLT64
:
1565 case R_X86_64_GOTPC32_TLSDESC
:
1566 case R_X86_64_TLSDESC_CALL
:
1567 /* This symbol requires a global offset table entry. */
1569 int tls_type
, old_tls_type
;
1573 default: tls_type
= GOT_NORMAL
; break;
1574 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1575 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1576 case R_X86_64_GOTPC32_TLSDESC
:
1577 case R_X86_64_TLSDESC_CALL
:
1578 tls_type
= GOT_TLS_GDESC
; break;
1583 if (r_type
== R_X86_64_GOTPLT64
)
1585 /* This relocation indicates that we also need
1586 a PLT entry, as this is a function. We don't need
1587 a PLT entry for local symbols. */
1589 h
->plt
.refcount
+= 1;
1591 h
->got
.refcount
+= 1;
1592 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1596 bfd_signed_vma
*local_got_refcounts
;
1598 /* This is a global offset table entry for a local symbol. */
1599 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1600 if (local_got_refcounts
== NULL
)
1604 size
= symtab_hdr
->sh_info
;
1605 size
*= sizeof (bfd_signed_vma
)
1606 + sizeof (bfd_vma
) + sizeof (char);
1607 local_got_refcounts
= ((bfd_signed_vma
*)
1608 bfd_zalloc (abfd
, size
));
1609 if (local_got_refcounts
== NULL
)
1611 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1612 elf_x86_64_local_tlsdesc_gotent (abfd
)
1613 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1614 elf_x86_64_local_got_tls_type (abfd
)
1615 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1617 local_got_refcounts
[r_symndx
] += 1;
1619 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1622 /* If a TLS symbol is accessed using IE at least once,
1623 there is no point to use dynamic model for it. */
1624 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1625 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1626 || tls_type
!= GOT_TLS_IE
))
1628 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1629 tls_type
= old_tls_type
;
1630 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1631 && GOT_TLS_GD_ANY_P (tls_type
))
1632 tls_type
|= old_tls_type
;
1636 name
= h
->root
.root
.string
;
1638 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1640 (*_bfd_error_handler
)
1641 (_("%B: '%s' accessed both as normal and thread local symbol"),
1643 bfd_set_error (bfd_error_bad_value
);
1648 if (old_tls_type
!= tls_type
)
1651 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1653 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1658 case R_X86_64_GOTOFF64
:
1659 case R_X86_64_GOTPC32
:
1660 case R_X86_64_GOTPC64
:
1662 if (htab
->elf
.sgot
== NULL
)
1664 if (htab
->elf
.dynobj
== NULL
)
1665 htab
->elf
.dynobj
= abfd
;
1666 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1672 case R_X86_64_PLT32
:
1673 /* This symbol requires a procedure linkage table entry. We
1674 actually build the entry in adjust_dynamic_symbol,
1675 because this might be a case of linking PIC code which is
1676 never referenced by a dynamic object, in which case we
1677 don't need to generate a procedure linkage table entry
1680 /* If this is a local symbol, we resolve it directly without
1681 creating a procedure linkage table entry. */
1686 h
->plt
.refcount
+= 1;
1689 case R_X86_64_PLTOFF64
:
1690 /* This tries to form the 'address' of a function relative
1691 to GOT. For global symbols we need a PLT entry. */
1695 h
->plt
.refcount
+= 1;
1699 case R_X86_64_SIZE32
:
1700 case R_X86_64_SIZE64
:
1705 if (!ABI_64_P (abfd
))
1710 /* Let's help debug shared library creation. These relocs
1711 cannot be used in shared libs. Don't error out for
1712 sections we don't care about, such as debug sections or
1713 non-constant sections. */
1715 && (sec
->flags
& SEC_ALLOC
) != 0
1716 && (sec
->flags
& SEC_READONLY
) != 0)
1719 name
= h
->root
.root
.string
;
1721 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1722 (*_bfd_error_handler
)
1723 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1724 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1725 bfd_set_error (bfd_error_bad_value
);
1736 if (h
!= NULL
&& info
->executable
)
1738 /* If this reloc is in a read-only section, we might
1739 need a copy reloc. We can't check reliably at this
1740 stage whether the section is read-only, as input
1741 sections have not yet been mapped to output sections.
1742 Tentatively set the flag for now, and correct in
1743 adjust_dynamic_symbol. */
1746 /* We may need a .plt entry if the function this reloc
1747 refers to is in a shared lib. */
1748 h
->plt
.refcount
+= 1;
1749 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1750 h
->pointer_equality_needed
= 1;
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
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
1777 && (sec
->flags
& SEC_ALLOC
) != 0
1778 && (! IS_X86_64_PCREL_TYPE (r_type
)
1780 && (! SYMBOLIC_BIND (info
, h
)
1781 || h
->root
.type
== bfd_link_hash_defweak
1782 || !h
->def_regular
))))
1783 || (ELIMINATE_COPY_RELOCS
1785 && (sec
->flags
& SEC_ALLOC
) != 0
1787 && (h
->root
.type
== bfd_link_hash_defweak
1788 || !h
->def_regular
)))
1790 struct elf_dyn_relocs
*p
;
1791 struct elf_dyn_relocs
**head
;
1793 /* We must copy these reloc types into the output file.
1794 Create a reloc section in dynobj and make room for
1798 if (htab
->elf
.dynobj
== NULL
)
1799 htab
->elf
.dynobj
= abfd
;
1801 sreloc
= _bfd_elf_make_dynamic_reloc_section
1802 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1803 abfd
, /*rela?*/ TRUE
);
1809 /* If this is a global symbol, we count the number of
1810 relocations we need for this symbol. */
1813 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1817 /* Track dynamic relocs needed for local syms too.
1818 We really need local syms available to do this
1823 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1828 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1832 /* Beware of type punned pointers vs strict aliasing
1834 vpp
= &(elf_section_data (s
)->local_dynrel
);
1835 head
= (struct elf_dyn_relocs
**)vpp
;
1839 if (p
== NULL
|| p
->sec
!= sec
)
1841 bfd_size_type amt
= sizeof *p
;
1843 p
= ((struct elf_dyn_relocs
*)
1844 bfd_alloc (htab
->elf
.dynobj
, amt
));
1855 /* Count size relocation as PC-relative relocation. */
1856 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
1861 /* This relocation describes the C++ object vtable hierarchy.
1862 Reconstruct it for later use during GC. */
1863 case R_X86_64_GNU_VTINHERIT
:
1864 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1868 /* This relocation describes which C++ vtable entries are actually
1869 used. Record for later use during GC. */
1870 case R_X86_64_GNU_VTENTRY
:
1871 BFD_ASSERT (h
!= NULL
);
1873 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1885 /* Return the section that should be marked against GC for a given
1889 elf_x86_64_gc_mark_hook (asection
*sec
,
1890 struct bfd_link_info
*info
,
1891 Elf_Internal_Rela
*rel
,
1892 struct elf_link_hash_entry
*h
,
1893 Elf_Internal_Sym
*sym
)
1896 switch (ELF32_R_TYPE (rel
->r_info
))
1898 case R_X86_64_GNU_VTINHERIT
:
1899 case R_X86_64_GNU_VTENTRY
:
1903 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1906 /* Update the got entry reference counts for the section being removed. */
1909 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1911 const Elf_Internal_Rela
*relocs
)
1913 struct elf_x86_64_link_hash_table
*htab
;
1914 Elf_Internal_Shdr
*symtab_hdr
;
1915 struct elf_link_hash_entry
**sym_hashes
;
1916 bfd_signed_vma
*local_got_refcounts
;
1917 const Elf_Internal_Rela
*rel
, *relend
;
1919 if (info
->relocatable
)
1922 htab
= elf_x86_64_hash_table (info
);
1926 elf_section_data (sec
)->local_dynrel
= NULL
;
1928 symtab_hdr
= &elf_symtab_hdr (abfd
);
1929 sym_hashes
= elf_sym_hashes (abfd
);
1930 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1932 htab
= elf_x86_64_hash_table (info
);
1933 relend
= relocs
+ sec
->reloc_count
;
1934 for (rel
= relocs
; rel
< relend
; rel
++)
1936 unsigned long r_symndx
;
1937 unsigned int r_type
;
1938 struct elf_link_hash_entry
*h
= NULL
;
1940 r_symndx
= htab
->r_sym (rel
->r_info
);
1941 if (r_symndx
>= symtab_hdr
->sh_info
)
1943 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1944 while (h
->root
.type
== bfd_link_hash_indirect
1945 || h
->root
.type
== bfd_link_hash_warning
)
1946 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1950 /* A local symbol. */
1951 Elf_Internal_Sym
*isym
;
1953 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1956 /* Check relocation against local STT_GNU_IFUNC symbol. */
1958 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1960 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1968 struct elf_x86_64_link_hash_entry
*eh
;
1969 struct elf_dyn_relocs
**pp
;
1970 struct elf_dyn_relocs
*p
;
1972 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1974 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1977 /* Everything must go for SEC. */
1983 r_type
= ELF32_R_TYPE (rel
->r_info
);
1984 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1985 symtab_hdr
, sym_hashes
,
1986 &r_type
, GOT_UNKNOWN
,
1987 rel
, relend
, h
, r_symndx
))
1992 case R_X86_64_TLSLD
:
1993 if (htab
->tls_ld_got
.refcount
> 0)
1994 htab
->tls_ld_got
.refcount
-= 1;
1997 case R_X86_64_TLSGD
:
1998 case R_X86_64_GOTPC32_TLSDESC
:
1999 case R_X86_64_TLSDESC_CALL
:
2000 case R_X86_64_GOTTPOFF
:
2001 case R_X86_64_GOT32
:
2002 case R_X86_64_GOTPCREL
:
2003 case R_X86_64_GOT64
:
2004 case R_X86_64_GOTPCREL64
:
2005 case R_X86_64_GOTPLT64
:
2008 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
2009 h
->plt
.refcount
-= 1;
2010 if (h
->got
.refcount
> 0)
2011 h
->got
.refcount
-= 1;
2012 if (h
->type
== STT_GNU_IFUNC
)
2014 if (h
->plt
.refcount
> 0)
2015 h
->plt
.refcount
-= 1;
2018 else if (local_got_refcounts
!= NULL
)
2020 if (local_got_refcounts
[r_symndx
] > 0)
2021 local_got_refcounts
[r_symndx
] -= 1;
2034 case R_X86_64_SIZE32
:
2035 case R_X86_64_SIZE64
:
2037 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2041 case R_X86_64_PLT32
:
2042 case R_X86_64_PLTOFF64
:
2045 if (h
->plt
.refcount
> 0)
2046 h
->plt
.refcount
-= 1;
2058 /* Adjust a symbol defined by a dynamic object and referenced by a
2059 regular object. The current definition is in some section of the
2060 dynamic object, but we're not including those sections. We have to
2061 change the definition to something the rest of the link can
2065 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2066 struct elf_link_hash_entry
*h
)
2068 struct elf_x86_64_link_hash_table
*htab
;
2070 struct elf_x86_64_link_hash_entry
*eh
;
2071 struct elf_dyn_relocs
*p
;
2073 /* STT_GNU_IFUNC symbol must go through PLT. */
2074 if (h
->type
== STT_GNU_IFUNC
)
2076 /* All local STT_GNU_IFUNC references must be treate as local
2077 calls via local PLT. */
2079 && SYMBOL_CALLS_LOCAL (info
, h
))
2081 bfd_size_type pc_count
= 0, count
= 0;
2082 struct elf_dyn_relocs
**pp
;
2084 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2085 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2087 pc_count
+= p
->pc_count
;
2088 p
->count
-= p
->pc_count
;
2097 if (pc_count
|| count
)
2101 if (h
->plt
.refcount
<= 0)
2102 h
->plt
.refcount
= 1;
2104 h
->plt
.refcount
+= 1;
2108 if (h
->plt
.refcount
<= 0)
2110 h
->plt
.offset
= (bfd_vma
) -1;
2116 /* If this is a function, put it in the procedure linkage table. We
2117 will fill in the contents of the procedure linkage table later,
2118 when we know the address of the .got section. */
2119 if (h
->type
== STT_FUNC
2122 if (h
->plt
.refcount
<= 0
2123 || SYMBOL_CALLS_LOCAL (info
, h
)
2124 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2125 && h
->root
.type
== bfd_link_hash_undefweak
))
2127 /* This case can occur if we saw a PLT32 reloc in an input
2128 file, but the symbol was never referred to by a dynamic
2129 object, or if all references were garbage collected. In
2130 such a case, we don't actually need to build a procedure
2131 linkage table, and we can just do a PC32 reloc instead. */
2132 h
->plt
.offset
= (bfd_vma
) -1;
2139 /* It's possible that we incorrectly decided a .plt reloc was
2140 needed for an R_X86_64_PC32 reloc to a non-function sym in
2141 check_relocs. We can't decide accurately between function and
2142 non-function syms in check-relocs; Objects loaded later in
2143 the link may change h->type. So fix it now. */
2144 h
->plt
.offset
= (bfd_vma
) -1;
2146 /* If this is a weak symbol, and there is a real definition, the
2147 processor independent code will have arranged for us to see the
2148 real definition first, and we can just use the same value. */
2149 if (h
->u
.weakdef
!= NULL
)
2151 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2152 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2153 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2154 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2155 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2156 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2160 /* This is a reference to a symbol defined by a dynamic object which
2161 is not a function. */
2163 /* If we are creating a shared library, we must presume that the
2164 only references to the symbol are via the global offset table.
2165 For such cases we need not do anything here; the relocations will
2166 be handled correctly by relocate_section. */
2170 /* If there are no references to this symbol that do not use the
2171 GOT, we don't need to generate a copy reloc. */
2172 if (!h
->non_got_ref
)
2175 /* If -z nocopyreloc was given, we won't generate them either. */
2176 if (info
->nocopyreloc
)
2182 if (ELIMINATE_COPY_RELOCS
)
2184 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2185 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2187 s
= p
->sec
->output_section
;
2188 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2192 /* If we didn't find any dynamic relocs in read-only sections, then
2193 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2201 /* We must allocate the symbol in our .dynbss section, which will
2202 become part of the .bss section of the executable. There will be
2203 an entry for this symbol in the .dynsym section. The dynamic
2204 object will contain position independent code, so all references
2205 from the dynamic object to this symbol will go through the global
2206 offset table. The dynamic linker will use the .dynsym entry to
2207 determine the address it must put in the global offset table, so
2208 both the dynamic object and the regular object will refer to the
2209 same memory location for the variable. */
2211 htab
= elf_x86_64_hash_table (info
);
2215 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2216 to copy the initial value out of the dynamic object and into the
2217 runtime process image. */
2218 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2220 const struct elf_backend_data
*bed
;
2221 bed
= get_elf_backend_data (info
->output_bfd
);
2222 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2228 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2231 /* Allocate space in .plt, .got and associated reloc sections for
2235 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2237 struct bfd_link_info
*info
;
2238 struct elf_x86_64_link_hash_table
*htab
;
2239 struct elf_x86_64_link_hash_entry
*eh
;
2240 struct elf_dyn_relocs
*p
;
2241 const struct elf_backend_data
*bed
;
2242 unsigned int plt_entry_size
;
2244 if (h
->root
.type
== bfd_link_hash_indirect
)
2247 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2249 info
= (struct bfd_link_info
*) inf
;
2250 htab
= elf_x86_64_hash_table (info
);
2253 bed
= get_elf_backend_data (info
->output_bfd
);
2254 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2256 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2257 here if it is defined and referenced in a non-shared object. */
2258 if (h
->type
== STT_GNU_IFUNC
2260 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2264 else if (htab
->elf
.dynamic_sections_created
2265 && h
->plt
.refcount
> 0)
2267 /* Make sure this symbol is output as a dynamic symbol.
2268 Undefined weak syms won't yet be marked as dynamic. */
2269 if (h
->dynindx
== -1
2270 && !h
->forced_local
)
2272 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2277 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2279 asection
*s
= htab
->elf
.splt
;
2281 /* If this is the first .plt entry, make room for the special
2284 s
->size
+= plt_entry_size
;
2286 h
->plt
.offset
= s
->size
;
2288 /* If this symbol is not defined in a regular file, and we are
2289 not generating a shared library, then set the symbol to this
2290 location in the .plt. This is required to make function
2291 pointers compare as equal between the normal executable and
2292 the shared library. */
2296 h
->root
.u
.def
.section
= s
;
2297 h
->root
.u
.def
.value
= h
->plt
.offset
;
2300 /* Make room for this entry. */
2301 s
->size
+= plt_entry_size
;
2303 /* We also need to make an entry in the .got.plt section, which
2304 will be placed in the .got section by the linker script. */
2305 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2307 /* We also need to make an entry in the .rela.plt section. */
2308 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2309 htab
->elf
.srelplt
->reloc_count
++;
2313 h
->plt
.offset
= (bfd_vma
) -1;
2319 h
->plt
.offset
= (bfd_vma
) -1;
2323 eh
->tlsdesc_got
= (bfd_vma
) -1;
2325 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2326 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2327 if (h
->got
.refcount
> 0
2330 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2332 h
->got
.offset
= (bfd_vma
) -1;
2334 else if (h
->got
.refcount
> 0)
2338 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2340 /* Make sure this symbol is output as a dynamic symbol.
2341 Undefined weak syms won't yet be marked as dynamic. */
2342 if (h
->dynindx
== -1
2343 && !h
->forced_local
)
2345 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2349 if (GOT_TLS_GDESC_P (tls_type
))
2351 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2352 - elf_x86_64_compute_jump_table_size (htab
);
2353 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2354 h
->got
.offset
= (bfd_vma
) -2;
2356 if (! GOT_TLS_GDESC_P (tls_type
)
2357 || GOT_TLS_GD_P (tls_type
))
2360 h
->got
.offset
= s
->size
;
2361 s
->size
+= GOT_ENTRY_SIZE
;
2362 if (GOT_TLS_GD_P (tls_type
))
2363 s
->size
+= GOT_ENTRY_SIZE
;
2365 dyn
= htab
->elf
.dynamic_sections_created
;
2366 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2368 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2369 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2370 || tls_type
== GOT_TLS_IE
)
2371 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2372 else if (GOT_TLS_GD_P (tls_type
))
2373 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2374 else if (! GOT_TLS_GDESC_P (tls_type
)
2375 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2376 || h
->root
.type
!= bfd_link_hash_undefweak
)
2378 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2379 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2380 if (GOT_TLS_GDESC_P (tls_type
))
2382 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2383 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2387 h
->got
.offset
= (bfd_vma
) -1;
2389 if (eh
->dyn_relocs
== NULL
)
2392 /* In the shared -Bsymbolic case, discard space allocated for
2393 dynamic pc-relative relocs against symbols which turn out to be
2394 defined in regular objects. For the normal shared case, discard
2395 space for pc-relative relocs that have become local due to symbol
2396 visibility changes. */
2400 /* Relocs that use pc_count are those that appear on a call
2401 insn, or certain REL relocs that can generated via assembly.
2402 We want calls to protected symbols to resolve directly to the
2403 function rather than going via the plt. If people want
2404 function pointer comparisons to work as expected then they
2405 should avoid writing weird assembly. */
2406 if (SYMBOL_CALLS_LOCAL (info
, h
))
2408 struct elf_dyn_relocs
**pp
;
2410 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2412 p
->count
-= p
->pc_count
;
2421 /* Also discard relocs on undefined weak syms with non-default
2423 if (eh
->dyn_relocs
!= NULL
2424 && h
->root
.type
== bfd_link_hash_undefweak
)
2426 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2427 eh
->dyn_relocs
= NULL
;
2429 /* Make sure undefined weak symbols are output as a dynamic
2431 else if (h
->dynindx
== -1
2432 && ! h
->forced_local
2433 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2438 else if (ELIMINATE_COPY_RELOCS
)
2440 /* For the non-shared case, discard space for relocs against
2441 symbols which turn out to need copy relocs or are not
2447 || (htab
->elf
.dynamic_sections_created
2448 && (h
->root
.type
== bfd_link_hash_undefweak
2449 || h
->root
.type
== bfd_link_hash_undefined
))))
2451 /* Make sure this symbol is output as a dynamic symbol.
2452 Undefined weak syms won't yet be marked as dynamic. */
2453 if (h
->dynindx
== -1
2454 && ! h
->forced_local
2455 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2458 /* If that succeeded, we know we'll be keeping all the
2460 if (h
->dynindx
!= -1)
2464 eh
->dyn_relocs
= NULL
;
2469 /* Finally, allocate space. */
2470 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2474 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2476 BFD_ASSERT (sreloc
!= NULL
);
2478 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2484 /* Allocate space in .plt, .got and associated reloc sections for
2485 local dynamic relocs. */
2488 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2490 struct elf_link_hash_entry
*h
2491 = (struct elf_link_hash_entry
*) *slot
;
2493 if (h
->type
!= STT_GNU_IFUNC
2497 || h
->root
.type
!= bfd_link_hash_defined
)
2500 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2503 /* Find any dynamic relocs that apply to read-only sections. */
2506 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2509 struct elf_x86_64_link_hash_entry
*eh
;
2510 struct elf_dyn_relocs
*p
;
2512 /* Skip local IFUNC symbols. */
2513 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2516 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2517 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2519 asection
*s
= p
->sec
->output_section
;
2521 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2523 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2525 info
->flags
|= DF_TEXTREL
;
2527 if (info
->warn_shared_textrel
&& info
->shared
)
2528 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2529 p
->sec
->owner
, h
->root
.root
.string
,
2532 /* Not an error, just cut short the traversal. */
2540 mov foo@GOTPCREL(%rip), %reg
2543 with the local symbol, foo. */
2546 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2547 struct bfd_link_info
*link_info
)
2549 Elf_Internal_Shdr
*symtab_hdr
;
2550 Elf_Internal_Rela
*internal_relocs
;
2551 Elf_Internal_Rela
*irel
, *irelend
;
2553 struct elf_x86_64_link_hash_table
*htab
;
2554 bfd_boolean changed_contents
;
2555 bfd_boolean changed_relocs
;
2556 bfd_signed_vma
*local_got_refcounts
;
2558 /* Don't even try to convert non-ELF outputs. */
2559 if (!is_elf_hash_table (link_info
->hash
))
2562 /* Nothing to do if there are no codes, no relocations or no output. */
2563 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2564 || sec
->reloc_count
== 0
2565 || discarded_section (sec
))
2568 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2570 /* Load the relocations for this section. */
2571 internal_relocs
= (_bfd_elf_link_read_relocs
2572 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2573 link_info
->keep_memory
));
2574 if (internal_relocs
== NULL
)
2577 htab
= elf_x86_64_hash_table (link_info
);
2578 changed_contents
= FALSE
;
2579 changed_relocs
= FALSE
;
2580 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2582 /* Get the section contents. */
2583 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2584 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2587 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2591 irelend
= internal_relocs
+ sec
->reloc_count
;
2592 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2594 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2595 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2597 struct elf_link_hash_entry
*h
;
2599 if (r_type
!= R_X86_64_GOTPCREL
)
2602 /* Get the symbol referred to by the reloc. */
2603 if (r_symndx
< symtab_hdr
->sh_info
)
2605 Elf_Internal_Sym
*isym
;
2607 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2610 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2611 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2612 && bfd_get_8 (input_bfd
,
2613 contents
+ irel
->r_offset
- 2) == 0x8b)
2615 bfd_put_8 (output_bfd
, 0x8d,
2616 contents
+ irel
->r_offset
- 2);
2617 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2618 if (local_got_refcounts
!= NULL
2619 && local_got_refcounts
[r_symndx
] > 0)
2620 local_got_refcounts
[r_symndx
] -= 1;
2621 changed_contents
= TRUE
;
2622 changed_relocs
= TRUE
;
2627 indx
= r_symndx
- symtab_hdr
->sh_info
;
2628 h
= elf_sym_hashes (abfd
)[indx
];
2629 BFD_ASSERT (h
!= NULL
);
2631 while (h
->root
.type
== bfd_link_hash_indirect
2632 || h
->root
.type
== bfd_link_hash_warning
)
2633 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2635 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2636 avoid optimizing _DYNAMIC since ld.so may use its link-time
2639 && h
->type
!= STT_GNU_IFUNC
2640 && h
!= htab
->elf
.hdynamic
2641 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2642 && bfd_get_8 (input_bfd
,
2643 contents
+ irel
->r_offset
- 2) == 0x8b)
2645 bfd_put_8 (output_bfd
, 0x8d,
2646 contents
+ irel
->r_offset
- 2);
2647 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2648 if (h
->got
.refcount
> 0)
2649 h
->got
.refcount
-= 1;
2650 changed_contents
= TRUE
;
2651 changed_relocs
= TRUE
;
2655 if (contents
!= NULL
2656 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2658 if (!changed_contents
&& !link_info
->keep_memory
)
2662 /* Cache the section contents for elf_link_input_bfd. */
2663 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2667 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2669 if (!changed_relocs
)
2670 free (internal_relocs
);
2672 elf_section_data (sec
)->relocs
= internal_relocs
;
2678 if (contents
!= NULL
2679 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2681 if (internal_relocs
!= NULL
2682 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2683 free (internal_relocs
);
2687 /* Set the sizes of the dynamic sections. */
2690 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2691 struct bfd_link_info
*info
)
2693 struct elf_x86_64_link_hash_table
*htab
;
2698 const struct elf_backend_data
*bed
;
2700 htab
= elf_x86_64_hash_table (info
);
2703 bed
= get_elf_backend_data (output_bfd
);
2705 dynobj
= htab
->elf
.dynobj
;
2709 if (htab
->elf
.dynamic_sections_created
)
2711 /* Set the contents of the .interp section to the interpreter. */
2712 if (info
->executable
)
2714 s
= bfd_get_linker_section (dynobj
, ".interp");
2717 s
->size
= htab
->dynamic_interpreter_size
;
2718 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2722 /* Set up .got offsets for local syms, and space for local dynamic
2724 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2726 bfd_signed_vma
*local_got
;
2727 bfd_signed_vma
*end_local_got
;
2728 char *local_tls_type
;
2729 bfd_vma
*local_tlsdesc_gotent
;
2730 bfd_size_type locsymcount
;
2731 Elf_Internal_Shdr
*symtab_hdr
;
2734 if (! is_x86_64_elf (ibfd
))
2737 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2739 struct elf_dyn_relocs
*p
;
2741 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2744 for (p
= (struct elf_dyn_relocs
*)
2745 (elf_section_data (s
)->local_dynrel
);
2749 if (!bfd_is_abs_section (p
->sec
)
2750 && bfd_is_abs_section (p
->sec
->output_section
))
2752 /* Input section has been discarded, either because
2753 it is a copy of a linkonce section or due to
2754 linker script /DISCARD/, so we'll be discarding
2757 else if (p
->count
!= 0)
2759 srel
= elf_section_data (p
->sec
)->sreloc
;
2760 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2761 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2762 && (info
->flags
& DF_TEXTREL
) == 0)
2764 info
->flags
|= DF_TEXTREL
;
2765 if (info
->warn_shared_textrel
&& info
->shared
)
2766 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2767 p
->sec
->owner
, p
->sec
);
2773 local_got
= elf_local_got_refcounts (ibfd
);
2777 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2778 locsymcount
= symtab_hdr
->sh_info
;
2779 end_local_got
= local_got
+ locsymcount
;
2780 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2781 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2783 srel
= htab
->elf
.srelgot
;
2784 for (; local_got
< end_local_got
;
2785 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2787 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2790 if (GOT_TLS_GDESC_P (*local_tls_type
))
2792 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2793 - elf_x86_64_compute_jump_table_size (htab
);
2794 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2795 *local_got
= (bfd_vma
) -2;
2797 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2798 || GOT_TLS_GD_P (*local_tls_type
))
2800 *local_got
= s
->size
;
2801 s
->size
+= GOT_ENTRY_SIZE
;
2802 if (GOT_TLS_GD_P (*local_tls_type
))
2803 s
->size
+= GOT_ENTRY_SIZE
;
2806 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2807 || *local_tls_type
== GOT_TLS_IE
)
2809 if (GOT_TLS_GDESC_P (*local_tls_type
))
2811 htab
->elf
.srelplt
->size
2812 += bed
->s
->sizeof_rela
;
2813 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2815 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2816 || GOT_TLS_GD_P (*local_tls_type
))
2817 srel
->size
+= bed
->s
->sizeof_rela
;
2821 *local_got
= (bfd_vma
) -1;
2825 if (htab
->tls_ld_got
.refcount
> 0)
2827 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2829 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2830 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2831 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2834 htab
->tls_ld_got
.offset
= -1;
2836 /* Allocate global sym .plt and .got entries, and space for global
2837 sym dynamic relocs. */
2838 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2841 /* Allocate .plt and .got entries, and space for local symbols. */
2842 htab_traverse (htab
->loc_hash_table
,
2843 elf_x86_64_allocate_local_dynrelocs
,
2846 /* For every jump slot reserved in the sgotplt, reloc_count is
2847 incremented. However, when we reserve space for TLS descriptors,
2848 it's not incremented, so in order to compute the space reserved
2849 for them, it suffices to multiply the reloc count by the jump
2852 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2853 so that R_X86_64_IRELATIVE entries come last. */
2854 if (htab
->elf
.srelplt
)
2856 htab
->sgotplt_jump_table_size
2857 = elf_x86_64_compute_jump_table_size (htab
);
2858 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
2860 else if (htab
->elf
.irelplt
)
2861 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
2863 if (htab
->tlsdesc_plt
)
2865 /* If we're not using lazy TLS relocations, don't generate the
2866 PLT and GOT entries they require. */
2867 if ((info
->flags
& DF_BIND_NOW
))
2868 htab
->tlsdesc_plt
= 0;
2871 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2872 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2873 /* Reserve room for the initial entry.
2874 FIXME: we could probably do away with it in this case. */
2875 if (htab
->elf
.splt
->size
== 0)
2876 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2877 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2878 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2882 if (htab
->elf
.sgotplt
)
2884 /* Don't allocate .got.plt section if there are no GOT nor PLT
2885 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2886 if ((htab
->elf
.hgot
== NULL
2887 || !htab
->elf
.hgot
->ref_regular_nonweak
)
2888 && (htab
->elf
.sgotplt
->size
2889 == get_elf_backend_data (output_bfd
)->got_header_size
)
2890 && (htab
->elf
.splt
== NULL
2891 || htab
->elf
.splt
->size
== 0)
2892 && (htab
->elf
.sgot
== NULL
2893 || htab
->elf
.sgot
->size
== 0)
2894 && (htab
->elf
.iplt
== NULL
2895 || htab
->elf
.iplt
->size
== 0)
2896 && (htab
->elf
.igotplt
== NULL
2897 || htab
->elf
.igotplt
->size
== 0))
2898 htab
->elf
.sgotplt
->size
= 0;
2901 if (htab
->plt_eh_frame
!= NULL
2902 && htab
->elf
.splt
!= NULL
2903 && htab
->elf
.splt
->size
!= 0
2904 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
2905 && _bfd_elf_eh_frame_present (info
))
2907 const struct elf_x86_64_backend_data
*arch_data
2908 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
2909 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
2912 /* We now have determined the sizes of the various dynamic sections.
2913 Allocate memory for them. */
2915 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2917 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2920 if (s
== htab
->elf
.splt
2921 || s
== htab
->elf
.sgot
2922 || s
== htab
->elf
.sgotplt
2923 || s
== htab
->elf
.iplt
2924 || s
== htab
->elf
.igotplt
2925 || s
== htab
->plt_eh_frame
2926 || s
== htab
->sdynbss
)
2928 /* Strip this section if we don't need it; see the
2931 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2933 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2936 /* We use the reloc_count field as a counter if we need
2937 to copy relocs into the output file. */
2938 if (s
!= htab
->elf
.srelplt
)
2943 /* It's not one of our sections, so don't allocate space. */
2949 /* If we don't need this section, strip it from the
2950 output file. This is mostly to handle .rela.bss and
2951 .rela.plt. We must create both sections in
2952 create_dynamic_sections, because they must be created
2953 before the linker maps input sections to output
2954 sections. The linker does that before
2955 adjust_dynamic_symbol is called, and it is that
2956 function which decides whether anything needs to go
2957 into these sections. */
2959 s
->flags
|= SEC_EXCLUDE
;
2963 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2966 /* Allocate memory for the section contents. We use bfd_zalloc
2967 here in case unused entries are not reclaimed before the
2968 section's contents are written out. This should not happen,
2969 but this way if it does, we get a R_X86_64_NONE reloc instead
2971 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2972 if (s
->contents
== NULL
)
2976 if (htab
->plt_eh_frame
!= NULL
2977 && htab
->plt_eh_frame
->contents
!= NULL
)
2979 const struct elf_x86_64_backend_data
*arch_data
2980 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
2982 memcpy (htab
->plt_eh_frame
->contents
,
2983 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
2984 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
2985 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
2988 if (htab
->elf
.dynamic_sections_created
)
2990 /* Add some entries to the .dynamic section. We fill in the
2991 values later, in elf_x86_64_finish_dynamic_sections, but we
2992 must add the entries now so that we get the correct size for
2993 the .dynamic section. The DT_DEBUG entry is filled in by the
2994 dynamic linker and used by the debugger. */
2995 #define add_dynamic_entry(TAG, VAL) \
2996 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2998 if (info
->executable
)
3000 if (!add_dynamic_entry (DT_DEBUG
, 0))
3004 if (htab
->elf
.splt
->size
!= 0)
3006 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3007 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3008 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3009 || !add_dynamic_entry (DT_JMPREL
, 0))
3012 if (htab
->tlsdesc_plt
3013 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3014 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3020 if (!add_dynamic_entry (DT_RELA
, 0)
3021 || !add_dynamic_entry (DT_RELASZ
, 0)
3022 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3025 /* If any dynamic relocs apply to a read-only section,
3026 then we need a DT_TEXTREL entry. */
3027 if ((info
->flags
& DF_TEXTREL
) == 0)
3028 elf_link_hash_traverse (&htab
->elf
,
3029 elf_x86_64_readonly_dynrelocs
,
3032 if ((info
->flags
& DF_TEXTREL
) != 0)
3034 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3039 #undef add_dynamic_entry
3045 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3046 struct bfd_link_info
*info
)
3048 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3052 struct elf_link_hash_entry
*tlsbase
;
3054 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3055 "_TLS_MODULE_BASE_",
3056 FALSE
, FALSE
, FALSE
);
3058 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3060 struct elf_x86_64_link_hash_table
*htab
;
3061 struct bfd_link_hash_entry
*bh
= NULL
;
3062 const struct elf_backend_data
*bed
3063 = get_elf_backend_data (output_bfd
);
3065 htab
= elf_x86_64_hash_table (info
);
3069 if (!(_bfd_generic_link_add_one_symbol
3070 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3071 tls_sec
, 0, NULL
, FALSE
,
3072 bed
->collect
, &bh
)))
3075 htab
->tls_module_base
= bh
;
3077 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3078 tlsbase
->def_regular
= 1;
3079 tlsbase
->other
= STV_HIDDEN
;
3080 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3087 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3088 executables. Rather than setting it to the beginning of the TLS
3089 section, we have to set it to the end. This function may be called
3090 multiple times, it is idempotent. */
3093 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3095 struct elf_x86_64_link_hash_table
*htab
;
3096 struct bfd_link_hash_entry
*base
;
3098 if (!info
->executable
)
3101 htab
= elf_x86_64_hash_table (info
);
3105 base
= htab
->tls_module_base
;
3109 base
->u
.def
.value
= htab
->elf
.tls_size
;
3112 /* Return the base VMA address which should be subtracted from real addresses
3113 when resolving @dtpoff relocation.
3114 This is PT_TLS segment p_vaddr. */
3117 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3119 /* If tls_sec is NULL, we should have signalled an error already. */
3120 if (elf_hash_table (info
)->tls_sec
== NULL
)
3122 return elf_hash_table (info
)->tls_sec
->vma
;
3125 /* Return the relocation value for @tpoff relocation
3126 if STT_TLS virtual address is ADDRESS. */
3129 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3131 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3132 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3133 bfd_vma static_tls_size
;
3135 /* If tls_segment is NULL, we should have signalled an error already. */
3136 if (htab
->tls_sec
== NULL
)
3139 /* Consider special static TLS alignment requirements. */
3140 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3141 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3144 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3148 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3150 /* Opcode Instruction
3153 0x0f 0x8x conditional jump */
3155 && (contents
[offset
- 1] == 0xe8
3156 || contents
[offset
- 1] == 0xe9))
3158 && contents
[offset
- 2] == 0x0f
3159 && (contents
[offset
- 1] & 0xf0) == 0x80));
3162 /* Relocate an x86_64 ELF section. */
3165 elf_x86_64_relocate_section (bfd
*output_bfd
,
3166 struct bfd_link_info
*info
,
3168 asection
*input_section
,
3170 Elf_Internal_Rela
*relocs
,
3171 Elf_Internal_Sym
*local_syms
,
3172 asection
**local_sections
)
3174 struct elf_x86_64_link_hash_table
*htab
;
3175 Elf_Internal_Shdr
*symtab_hdr
;
3176 struct elf_link_hash_entry
**sym_hashes
;
3177 bfd_vma
*local_got_offsets
;
3178 bfd_vma
*local_tlsdesc_gotents
;
3179 Elf_Internal_Rela
*rel
;
3180 Elf_Internal_Rela
*relend
;
3181 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3183 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3185 htab
= elf_x86_64_hash_table (info
);
3188 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3189 sym_hashes
= elf_sym_hashes (input_bfd
);
3190 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3191 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3193 elf_x86_64_set_tls_module_base (info
);
3196 relend
= relocs
+ input_section
->reloc_count
;
3197 for (; rel
< relend
; rel
++)
3199 unsigned int r_type
;
3200 reloc_howto_type
*howto
;
3201 unsigned long r_symndx
;
3202 struct elf_link_hash_entry
*h
;
3203 Elf_Internal_Sym
*sym
;
3205 bfd_vma off
, offplt
;
3207 bfd_boolean unresolved_reloc
;
3208 bfd_reloc_status_type r
;
3213 r_type
= ELF32_R_TYPE (rel
->r_info
);
3214 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3215 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3218 if (r_type
>= (int) R_X86_64_standard
)
3220 (*_bfd_error_handler
)
3221 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3222 input_bfd
, input_section
, r_type
);
3223 bfd_set_error (bfd_error_bad_value
);
3227 if (r_type
!= (int) R_X86_64_32
3228 || ABI_64_P (output_bfd
))
3229 howto
= x86_64_elf_howto_table
+ r_type
;
3231 howto
= (x86_64_elf_howto_table
3232 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3233 r_symndx
= htab
->r_sym (rel
->r_info
);
3237 unresolved_reloc
= FALSE
;
3238 if (r_symndx
< symtab_hdr
->sh_info
)
3240 sym
= local_syms
+ r_symndx
;
3241 sec
= local_sections
[r_symndx
];
3243 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3245 st_size
= sym
->st_size
;
3247 /* Relocate against local STT_GNU_IFUNC symbol. */
3248 if (!info
->relocatable
3249 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3251 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3256 /* Set STT_GNU_IFUNC symbol value. */
3257 h
->root
.u
.def
.value
= sym
->st_value
;
3258 h
->root
.u
.def
.section
= sec
;
3263 bfd_boolean warned ATTRIBUTE_UNUSED
;
3265 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3266 r_symndx
, symtab_hdr
, sym_hashes
,
3268 unresolved_reloc
, warned
);
3272 if (sec
!= NULL
&& discarded_section (sec
))
3273 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3274 rel
, 1, relend
, howto
, 0, contents
);
3276 if (info
->relocatable
)
3279 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3281 if (r_type
== R_X86_64_64
)
3283 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3284 zero-extend it to 64bit if addend is zero. */
3285 r_type
= R_X86_64_32
;
3286 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3288 else if (r_type
== R_X86_64_SIZE64
)
3290 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3291 zero-extend it to 64bit if addend is zero. */
3292 r_type
= R_X86_64_SIZE32
;
3293 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3297 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3298 it here if it is defined in a non-shared object. */
3300 && h
->type
== STT_GNU_IFUNC
3307 if ((input_section
->flags
& SEC_ALLOC
) == 0
3308 || h
->plt
.offset
== (bfd_vma
) -1)
3311 /* STT_GNU_IFUNC symbol must go through PLT. */
3312 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3313 relocation
= (plt
->output_section
->vma
3314 + plt
->output_offset
+ h
->plt
.offset
);
3319 if (h
->root
.root
.string
)
3320 name
= h
->root
.root
.string
;
3322 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3324 (*_bfd_error_handler
)
3325 (_("%B: relocation %s against STT_GNU_IFUNC "
3326 "symbol `%s' isn't handled by %s"), input_bfd
,
3327 x86_64_elf_howto_table
[r_type
].name
,
3328 name
, __FUNCTION__
);
3329 bfd_set_error (bfd_error_bad_value
);
3338 if (ABI_64_P (output_bfd
))
3342 if (rel
->r_addend
!= 0)
3344 if (h
->root
.root
.string
)
3345 name
= h
->root
.root
.string
;
3347 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3349 (*_bfd_error_handler
)
3350 (_("%B: relocation %s against STT_GNU_IFUNC "
3351 "symbol `%s' has non-zero addend: %d"),
3352 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3353 name
, rel
->r_addend
);
3354 bfd_set_error (bfd_error_bad_value
);
3358 /* Generate dynamic relcoation only when there is a
3359 non-GOT reference in a shared object. */
3360 if (info
->shared
&& h
->non_got_ref
)
3362 Elf_Internal_Rela outrel
;
3365 /* Need a dynamic relocation to get the real function
3367 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3371 if (outrel
.r_offset
== (bfd_vma
) -1
3372 || outrel
.r_offset
== (bfd_vma
) -2)
3375 outrel
.r_offset
+= (input_section
->output_section
->vma
3376 + input_section
->output_offset
);
3378 if (h
->dynindx
== -1
3380 || info
->executable
)
3382 /* This symbol is resolved locally. */
3383 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3384 outrel
.r_addend
= (h
->root
.u
.def
.value
3385 + h
->root
.u
.def
.section
->output_section
->vma
3386 + h
->root
.u
.def
.section
->output_offset
);
3390 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3391 outrel
.r_addend
= 0;
3394 sreloc
= htab
->elf
.irelifunc
;
3395 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3397 /* If this reloc is against an external symbol, we
3398 do not want to fiddle with the addend. Otherwise,
3399 we need to include the symbol value so that it
3400 becomes an addend for the dynamic reloc. For an
3401 internal symbol, we have updated addend. */
3407 case R_X86_64_PLT32
:
3410 case R_X86_64_GOTPCREL
:
3411 case R_X86_64_GOTPCREL64
:
3412 base_got
= htab
->elf
.sgot
;
3413 off
= h
->got
.offset
;
3415 if (base_got
== NULL
)
3418 if (off
== (bfd_vma
) -1)
3420 /* We can't use h->got.offset here to save state, or
3421 even just remember the offset, as finish_dynamic_symbol
3422 would use that as offset into .got. */
3424 if (htab
->elf
.splt
!= NULL
)
3426 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3427 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3428 base_got
= htab
->elf
.sgotplt
;
3432 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3433 off
= plt_index
* GOT_ENTRY_SIZE
;
3434 base_got
= htab
->elf
.igotplt
;
3437 if (h
->dynindx
== -1
3441 /* This references the local defitionion. We must
3442 initialize this entry in the global offset table.
3443 Since the offset must always be a multiple of 8,
3444 we use the least significant bit to record
3445 whether we have initialized it already.
3447 When doing a dynamic link, we create a .rela.got
3448 relocation entry to initialize the value. This
3449 is done in the finish_dynamic_symbol routine. */
3454 bfd_put_64 (output_bfd
, relocation
,
3455 base_got
->contents
+ off
);
3456 /* Note that this is harmless for the GOTPLT64
3457 case, as -1 | 1 still is -1. */
3463 relocation
= (base_got
->output_section
->vma
3464 + base_got
->output_offset
+ off
);
3470 /* When generating a shared object, the relocations handled here are
3471 copied into the output file to be resolved at run time. */
3474 case R_X86_64_GOT32
:
3475 case R_X86_64_GOT64
:
3476 /* Relocation is to the entry for this symbol in the global
3478 case R_X86_64_GOTPCREL
:
3479 case R_X86_64_GOTPCREL64
:
3480 /* Use global offset table entry as symbol value. */
3481 case R_X86_64_GOTPLT64
:
3482 /* This is the same as GOT64 for relocation purposes, but
3483 indicates the existence of a PLT entry. The difficulty is,
3484 that we must calculate the GOT slot offset from the PLT
3485 offset, if this symbol got a PLT entry (it was global).
3486 Additionally if it's computed from the PLT entry, then that
3487 GOT offset is relative to .got.plt, not to .got. */
3488 base_got
= htab
->elf
.sgot
;
3490 if (htab
->elf
.sgot
== NULL
)
3497 off
= h
->got
.offset
;
3499 && h
->plt
.offset
!= (bfd_vma
)-1
3500 && off
== (bfd_vma
)-1)
3502 /* We can't use h->got.offset here to save
3503 state, or even just remember the offset, as
3504 finish_dynamic_symbol would use that as offset into
3506 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3507 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3508 base_got
= htab
->elf
.sgotplt
;
3511 dyn
= htab
->elf
.dynamic_sections_created
;
3513 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3515 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3516 || (ELF_ST_VISIBILITY (h
->other
)
3517 && h
->root
.type
== bfd_link_hash_undefweak
))
3519 /* This is actually a static link, or it is a -Bsymbolic
3520 link and the symbol is defined locally, or the symbol
3521 was forced to be local because of a version file. We
3522 must initialize this entry in the global offset table.
3523 Since the offset must always be a multiple of 8, we
3524 use the least significant bit to record whether we
3525 have initialized it already.
3527 When doing a dynamic link, we create a .rela.got
3528 relocation entry to initialize the value. This is
3529 done in the finish_dynamic_symbol routine. */
3534 bfd_put_64 (output_bfd
, relocation
,
3535 base_got
->contents
+ off
);
3536 /* Note that this is harmless for the GOTPLT64 case,
3537 as -1 | 1 still is -1. */
3542 unresolved_reloc
= FALSE
;
3546 if (local_got_offsets
== NULL
)
3549 off
= local_got_offsets
[r_symndx
];
3551 /* The offset must always be a multiple of 8. We use
3552 the least significant bit to record whether we have
3553 already generated the necessary reloc. */
3558 bfd_put_64 (output_bfd
, relocation
,
3559 base_got
->contents
+ off
);
3564 Elf_Internal_Rela outrel
;
3566 /* We need to generate a R_X86_64_RELATIVE reloc
3567 for the dynamic linker. */
3568 s
= htab
->elf
.srelgot
;
3572 outrel
.r_offset
= (base_got
->output_section
->vma
3573 + base_got
->output_offset
3575 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3576 outrel
.r_addend
= relocation
;
3577 elf_append_rela (output_bfd
, s
, &outrel
);
3580 local_got_offsets
[r_symndx
] |= 1;
3584 if (off
>= (bfd_vma
) -2)
3587 relocation
= base_got
->output_section
->vma
3588 + base_got
->output_offset
+ off
;
3589 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3590 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3591 - htab
->elf
.sgotplt
->output_offset
;
3595 case R_X86_64_GOTOFF64
:
3596 /* Relocation is relative to the start of the global offset
3599 /* Check to make sure it isn't a protected function symbol
3600 for shared library since it may not be local when used
3601 as function address. */
3602 if (!info
->executable
3604 && !SYMBOLIC_BIND (info
, h
)
3606 && h
->type
== STT_FUNC
3607 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3609 (*_bfd_error_handler
)
3610 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3611 input_bfd
, h
->root
.root
.string
);
3612 bfd_set_error (bfd_error_bad_value
);
3616 /* Note that sgot is not involved in this
3617 calculation. We always want the start of .got.plt. If we
3618 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3619 permitted by the ABI, we might have to change this
3621 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3622 + htab
->elf
.sgotplt
->output_offset
;
3625 case R_X86_64_GOTPC32
:
3626 case R_X86_64_GOTPC64
:
3627 /* Use global offset table as symbol value. */
3628 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3629 + htab
->elf
.sgotplt
->output_offset
;
3630 unresolved_reloc
= FALSE
;
3633 case R_X86_64_PLTOFF64
:
3634 /* Relocation is PLT entry relative to GOT. For local
3635 symbols it's the symbol itself relative to GOT. */
3637 /* See PLT32 handling. */
3638 && h
->plt
.offset
!= (bfd_vma
) -1
3639 && htab
->elf
.splt
!= NULL
)
3641 relocation
= (htab
->elf
.splt
->output_section
->vma
3642 + htab
->elf
.splt
->output_offset
3644 unresolved_reloc
= FALSE
;
3647 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3648 + htab
->elf
.sgotplt
->output_offset
;
3651 case R_X86_64_PLT32
:
3652 /* Relocation is to the entry for this symbol in the
3653 procedure linkage table. */
3655 /* Resolve a PLT32 reloc against a local symbol directly,
3656 without using the procedure linkage table. */
3660 if (h
->plt
.offset
== (bfd_vma
) -1
3661 || htab
->elf
.splt
== NULL
)
3663 /* We didn't make a PLT entry for this symbol. This
3664 happens when statically linking PIC code, or when
3665 using -Bsymbolic. */
3669 relocation
= (htab
->elf
.splt
->output_section
->vma
3670 + htab
->elf
.splt
->output_offset
3672 unresolved_reloc
= FALSE
;
3675 case R_X86_64_SIZE32
:
3676 case R_X86_64_SIZE64
:
3677 /* Set to symbol size. */
3678 relocation
= st_size
;
3685 && (input_section
->flags
& SEC_ALLOC
) != 0
3686 && (input_section
->flags
& SEC_READONLY
) != 0
3689 bfd_boolean fail
= FALSE
;
3691 = (r_type
== R_X86_64_PC32
3692 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3694 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3696 /* Symbol is referenced locally. Make sure it is
3697 defined locally or for a branch. */
3698 fail
= !h
->def_regular
&& !branch
;
3702 /* Symbol isn't referenced locally. We only allow
3703 branch to symbol with non-default visibility. */
3705 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3712 const char *pic
= "";
3714 switch (ELF_ST_VISIBILITY (h
->other
))
3717 v
= _("hidden symbol");
3720 v
= _("internal symbol");
3723 v
= _("protected symbol");
3727 pic
= _("; recompile with -fPIC");
3732 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3734 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3736 (*_bfd_error_handler
) (fmt
, input_bfd
,
3737 x86_64_elf_howto_table
[r_type
].name
,
3738 v
, h
->root
.root
.string
, pic
);
3739 bfd_set_error (bfd_error_bad_value
);
3750 /* FIXME: The ABI says the linker should make sure the value is
3751 the same when it's zeroextended to 64 bit. */
3754 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3759 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3760 || h
->root
.type
!= bfd_link_hash_undefweak
)
3761 && ((! IS_X86_64_PCREL_TYPE (r_type
)
3762 && r_type
!= R_X86_64_SIZE32
3763 && r_type
!= R_X86_64_SIZE64
)
3764 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3765 || (ELIMINATE_COPY_RELOCS
3772 || h
->root
.type
== bfd_link_hash_undefweak
3773 || h
->root
.type
== bfd_link_hash_undefined
)))
3775 Elf_Internal_Rela outrel
;
3776 bfd_boolean skip
, relocate
;
3779 /* When generating a shared object, these relocations
3780 are copied into the output file to be resolved at run
3786 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3788 if (outrel
.r_offset
== (bfd_vma
) -1)
3790 else if (outrel
.r_offset
== (bfd_vma
) -2)
3791 skip
= TRUE
, relocate
= TRUE
;
3793 outrel
.r_offset
+= (input_section
->output_section
->vma
3794 + input_section
->output_offset
);
3797 memset (&outrel
, 0, sizeof outrel
);
3799 /* h->dynindx may be -1 if this symbol was marked to
3803 && (IS_X86_64_PCREL_TYPE (r_type
)
3805 || ! SYMBOLIC_BIND (info
, h
)
3806 || ! h
->def_regular
))
3808 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3809 outrel
.r_addend
= rel
->r_addend
;
3813 /* This symbol is local, or marked to become local. */
3814 if (r_type
== htab
->pointer_r_type
)
3817 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3818 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3820 else if (r_type
== R_X86_64_64
3821 && !ABI_64_P (output_bfd
))
3824 outrel
.r_info
= htab
->r_info (0,
3825 R_X86_64_RELATIVE64
);
3826 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3827 /* Check addend overflow. */
3828 if ((outrel
.r_addend
& 0x80000000)
3829 != (rel
->r_addend
& 0x80000000))
3832 int addend
= rel
->r_addend
;
3833 if (h
&& h
->root
.root
.string
)
3834 name
= h
->root
.root
.string
;
3836 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3839 (*_bfd_error_handler
)
3840 (_("%B: addend -0x%x in relocation %s against "
3841 "symbol `%s' at 0x%lx in section `%A' is "
3843 input_bfd
, input_section
, addend
,
3844 x86_64_elf_howto_table
[r_type
].name
,
3845 name
, (unsigned long) rel
->r_offset
);
3847 (*_bfd_error_handler
)
3848 (_("%B: addend 0x%x in relocation %s against "
3849 "symbol `%s' at 0x%lx in section `%A' is "
3851 input_bfd
, input_section
, addend
,
3852 x86_64_elf_howto_table
[r_type
].name
,
3853 name
, (unsigned long) rel
->r_offset
);
3854 bfd_set_error (bfd_error_bad_value
);
3862 if (bfd_is_abs_section (sec
))
3864 else if (sec
== NULL
|| sec
->owner
== NULL
)
3866 bfd_set_error (bfd_error_bad_value
);
3873 /* We are turning this relocation into one
3874 against a section symbol. It would be
3875 proper to subtract the symbol's value,
3876 osec->vma, from the emitted reloc addend,
3877 but ld.so expects buggy relocs. */
3878 osec
= sec
->output_section
;
3879 sindx
= elf_section_data (osec
)->dynindx
;
3882 asection
*oi
= htab
->elf
.text_index_section
;
3883 sindx
= elf_section_data (oi
)->dynindx
;
3885 BFD_ASSERT (sindx
!= 0);
3888 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3889 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3893 sreloc
= elf_section_data (input_section
)->sreloc
;
3895 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3897 r
= bfd_reloc_notsupported
;
3898 goto check_relocation_error
;
3901 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3903 /* If this reloc is against an external symbol, we do
3904 not want to fiddle with the addend. Otherwise, we
3905 need to include the symbol value so that it becomes
3906 an addend for the dynamic reloc. */
3913 case R_X86_64_TLSGD
:
3914 case R_X86_64_GOTPC32_TLSDESC
:
3915 case R_X86_64_TLSDESC_CALL
:
3916 case R_X86_64_GOTTPOFF
:
3917 tls_type
= GOT_UNKNOWN
;
3918 if (h
== NULL
&& local_got_offsets
)
3919 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3921 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3923 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3924 input_section
, contents
,
3925 symtab_hdr
, sym_hashes
,
3926 &r_type
, tls_type
, rel
,
3927 relend
, h
, r_symndx
))
3930 if (r_type
== R_X86_64_TPOFF32
)
3932 bfd_vma roff
= rel
->r_offset
;
3934 BFD_ASSERT (! unresolved_reloc
);
3936 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3938 /* GD->LE transition. For 64bit, change
3939 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3940 .word 0x6666; rex64; call __tls_get_addr
3943 leaq foo@tpoff(%rax), %rax
3945 leaq foo@tlsgd(%rip), %rdi
3946 .word 0x6666; rex64; call __tls_get_addr
3949 leaq foo@tpoff(%rax), %rax */
3950 if (ABI_64_P (output_bfd
))
3951 memcpy (contents
+ roff
- 4,
3952 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3955 memcpy (contents
+ roff
- 3,
3956 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3958 bfd_put_32 (output_bfd
,
3959 elf_x86_64_tpoff (info
, relocation
),
3960 contents
+ roff
+ 8);
3961 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3965 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3967 /* GDesc -> LE transition.
3968 It's originally something like:
3969 leaq x@tlsdesc(%rip), %rax
3972 movl $x@tpoff, %rax. */
3974 unsigned int val
, type
;
3976 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3977 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3978 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3979 contents
+ roff
- 3);
3980 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3981 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3982 contents
+ roff
- 1);
3983 bfd_put_32 (output_bfd
,
3984 elf_x86_64_tpoff (info
, relocation
),
3988 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3990 /* GDesc -> LE transition.
3995 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3996 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3999 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4001 /* IE->LE transition:
4002 Originally it can be one of:
4003 movq foo@gottpoff(%rip), %reg
4004 addq foo@gottpoff(%rip), %reg
4007 leaq foo(%reg), %reg
4010 unsigned int val
, type
, reg
;
4012 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4013 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4014 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4020 bfd_put_8 (output_bfd
, 0x49,
4021 contents
+ roff
- 3);
4022 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4023 bfd_put_8 (output_bfd
, 0x41,
4024 contents
+ roff
- 3);
4025 bfd_put_8 (output_bfd
, 0xc7,
4026 contents
+ roff
- 2);
4027 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4028 contents
+ roff
- 1);
4032 /* addq -> addq - addressing with %rsp/%r12 is
4035 bfd_put_8 (output_bfd
, 0x49,
4036 contents
+ roff
- 3);
4037 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4038 bfd_put_8 (output_bfd
, 0x41,
4039 contents
+ roff
- 3);
4040 bfd_put_8 (output_bfd
, 0x81,
4041 contents
+ roff
- 2);
4042 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4043 contents
+ roff
- 1);
4049 bfd_put_8 (output_bfd
, 0x4d,
4050 contents
+ roff
- 3);
4051 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4052 bfd_put_8 (output_bfd
, 0x45,
4053 contents
+ roff
- 3);
4054 bfd_put_8 (output_bfd
, 0x8d,
4055 contents
+ roff
- 2);
4056 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4057 contents
+ roff
- 1);
4059 bfd_put_32 (output_bfd
,
4060 elf_x86_64_tpoff (info
, relocation
),
4068 if (htab
->elf
.sgot
== NULL
)
4073 off
= h
->got
.offset
;
4074 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4078 if (local_got_offsets
== NULL
)
4081 off
= local_got_offsets
[r_symndx
];
4082 offplt
= local_tlsdesc_gotents
[r_symndx
];
4089 Elf_Internal_Rela outrel
;
4093 if (htab
->elf
.srelgot
== NULL
)
4096 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4098 if (GOT_TLS_GDESC_P (tls_type
))
4100 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4101 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4102 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4103 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4104 + htab
->elf
.sgotplt
->output_offset
4106 + htab
->sgotplt_jump_table_size
);
4107 sreloc
= htab
->elf
.srelplt
;
4109 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4111 outrel
.r_addend
= 0;
4112 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4115 sreloc
= htab
->elf
.srelgot
;
4117 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4118 + htab
->elf
.sgot
->output_offset
+ off
);
4120 if (GOT_TLS_GD_P (tls_type
))
4121 dr_type
= R_X86_64_DTPMOD64
;
4122 else if (GOT_TLS_GDESC_P (tls_type
))
4125 dr_type
= R_X86_64_TPOFF64
;
4127 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4128 outrel
.r_addend
= 0;
4129 if ((dr_type
== R_X86_64_TPOFF64
4130 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4131 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4132 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4134 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4136 if (GOT_TLS_GD_P (tls_type
))
4140 BFD_ASSERT (! unresolved_reloc
);
4141 bfd_put_64 (output_bfd
,
4142 relocation
- elf_x86_64_dtpoff_base (info
),
4143 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4147 bfd_put_64 (output_bfd
, 0,
4148 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4149 outrel
.r_info
= htab
->r_info (indx
,
4151 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4152 elf_append_rela (output_bfd
, sreloc
,
4161 local_got_offsets
[r_symndx
] |= 1;
4164 if (off
>= (bfd_vma
) -2
4165 && ! GOT_TLS_GDESC_P (tls_type
))
4167 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4169 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4170 || r_type
== R_X86_64_TLSDESC_CALL
)
4171 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4172 + htab
->elf
.sgotplt
->output_offset
4173 + offplt
+ htab
->sgotplt_jump_table_size
;
4175 relocation
= htab
->elf
.sgot
->output_section
->vma
4176 + htab
->elf
.sgot
->output_offset
+ off
;
4177 unresolved_reloc
= FALSE
;
4181 bfd_vma roff
= rel
->r_offset
;
4183 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4185 /* GD->IE transition. For 64bit, change
4186 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4187 .word 0x6666; rex64; call __tls_get_addr@plt
4190 addq foo@gottpoff(%rip), %rax
4192 leaq foo@tlsgd(%rip), %rdi
4193 .word 0x6666; rex64; call __tls_get_addr@plt
4196 addq foo@gottpoff(%rip), %rax */
4197 if (ABI_64_P (output_bfd
))
4198 memcpy (contents
+ roff
- 4,
4199 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4202 memcpy (contents
+ roff
- 3,
4203 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4206 relocation
= (htab
->elf
.sgot
->output_section
->vma
4207 + htab
->elf
.sgot
->output_offset
+ off
4209 - input_section
->output_section
->vma
4210 - input_section
->output_offset
4212 bfd_put_32 (output_bfd
, relocation
,
4213 contents
+ roff
+ 8);
4214 /* Skip R_X86_64_PLT32. */
4218 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4220 /* GDesc -> IE transition.
4221 It's originally something like:
4222 leaq x@tlsdesc(%rip), %rax
4225 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4227 /* Now modify the instruction as appropriate. To
4228 turn a leaq into a movq in the form we use it, it
4229 suffices to change the second byte from 0x8d to
4231 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4233 bfd_put_32 (output_bfd
,
4234 htab
->elf
.sgot
->output_section
->vma
4235 + htab
->elf
.sgot
->output_offset
+ off
4237 - input_section
->output_section
->vma
4238 - input_section
->output_offset
4243 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4245 /* GDesc -> IE transition.
4252 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4253 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4261 case R_X86_64_TLSLD
:
4262 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4263 input_section
, contents
,
4264 symtab_hdr
, sym_hashes
,
4265 &r_type
, GOT_UNKNOWN
,
4266 rel
, relend
, h
, r_symndx
))
4269 if (r_type
!= R_X86_64_TLSLD
)
4271 /* LD->LE transition:
4272 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4273 For 64bit, we change it into:
4274 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4275 For 32bit, we change it into:
4276 nopl 0x0(%rax); movl %fs:0, %eax. */
4278 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4279 if (ABI_64_P (output_bfd
))
4280 memcpy (contents
+ rel
->r_offset
- 3,
4281 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4283 memcpy (contents
+ rel
->r_offset
- 3,
4284 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4285 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4290 if (htab
->elf
.sgot
== NULL
)
4293 off
= htab
->tls_ld_got
.offset
;
4298 Elf_Internal_Rela outrel
;
4300 if (htab
->elf
.srelgot
== NULL
)
4303 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4304 + htab
->elf
.sgot
->output_offset
+ off
);
4306 bfd_put_64 (output_bfd
, 0,
4307 htab
->elf
.sgot
->contents
+ off
);
4308 bfd_put_64 (output_bfd
, 0,
4309 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4310 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4311 outrel
.r_addend
= 0;
4312 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4314 htab
->tls_ld_got
.offset
|= 1;
4316 relocation
= htab
->elf
.sgot
->output_section
->vma
4317 + htab
->elf
.sgot
->output_offset
+ off
;
4318 unresolved_reloc
= FALSE
;
4321 case R_X86_64_DTPOFF32
:
4322 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4323 relocation
-= elf_x86_64_dtpoff_base (info
);
4325 relocation
= elf_x86_64_tpoff (info
, relocation
);
4328 case R_X86_64_TPOFF32
:
4329 case R_X86_64_TPOFF64
:
4330 BFD_ASSERT (info
->executable
);
4331 relocation
= elf_x86_64_tpoff (info
, relocation
);
4338 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4339 because such sections are not SEC_ALLOC and thus ld.so will
4340 not process them. */
4341 if (unresolved_reloc
4342 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4344 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4345 rel
->r_offset
) != (bfd_vma
) -1)
4347 (*_bfd_error_handler
)
4348 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4351 (long) rel
->r_offset
,
4353 h
->root
.root
.string
);
4358 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4359 contents
, rel
->r_offset
,
4360 relocation
, rel
->r_addend
);
4362 check_relocation_error
:
4363 if (r
!= bfd_reloc_ok
)
4368 name
= h
->root
.root
.string
;
4371 name
= bfd_elf_string_from_elf_section (input_bfd
,
4372 symtab_hdr
->sh_link
,
4377 name
= bfd_section_name (input_bfd
, sec
);
4380 if (r
== bfd_reloc_overflow
)
4382 if (! ((*info
->callbacks
->reloc_overflow
)
4383 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4384 (bfd_vma
) 0, input_bfd
, input_section
,
4390 (*_bfd_error_handler
)
4391 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4392 input_bfd
, input_section
,
4393 (long) rel
->r_offset
, name
, (int) r
);
4402 /* Finish up dynamic symbol handling. We set the contents of various
4403 dynamic sections here. */
4406 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4407 struct bfd_link_info
*info
,
4408 struct elf_link_hash_entry
*h
,
4409 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4411 struct elf_x86_64_link_hash_table
*htab
;
4412 const struct elf_x86_64_backend_data
*const abed
4413 = get_elf_x86_64_backend_data (output_bfd
);
4415 htab
= elf_x86_64_hash_table (info
);
4419 if (h
->plt
.offset
!= (bfd_vma
) -1)
4423 Elf_Internal_Rela rela
;
4425 asection
*plt
, *gotplt
, *relplt
;
4426 const struct elf_backend_data
*bed
;
4428 /* When building a static executable, use .iplt, .igot.plt and
4429 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4430 if (htab
->elf
.splt
!= NULL
)
4432 plt
= htab
->elf
.splt
;
4433 gotplt
= htab
->elf
.sgotplt
;
4434 relplt
= htab
->elf
.srelplt
;
4438 plt
= htab
->elf
.iplt
;
4439 gotplt
= htab
->elf
.igotplt
;
4440 relplt
= htab
->elf
.irelplt
;
4443 /* This symbol has an entry in the procedure linkage table. Set
4445 if ((h
->dynindx
== -1
4446 && !((h
->forced_local
|| info
->executable
)
4448 && h
->type
== STT_GNU_IFUNC
))
4454 /* Get the index in the procedure linkage table which
4455 corresponds to this symbol. This is the index of this symbol
4456 in all the symbols for which we are making plt entries. The
4457 first entry in the procedure linkage table is reserved.
4459 Get the offset into the .got table of the entry that
4460 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4461 bytes. The first three are reserved for the dynamic linker.
4463 For static executables, we don't reserve anything. */
4465 if (plt
== htab
->elf
.splt
)
4467 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4468 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4472 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4473 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4476 /* Fill in the entry in the procedure linkage table. */
4477 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4478 abed
->plt_entry_size
);
4480 /* Insert the relocation positions of the plt section. */
4482 /* Put offset the PC-relative instruction referring to the GOT entry,
4483 subtracting the size of that instruction. */
4484 bfd_put_32 (output_bfd
,
4485 (gotplt
->output_section
->vma
4486 + gotplt
->output_offset
4488 - plt
->output_section
->vma
4489 - plt
->output_offset
4491 - abed
->plt_got_insn_size
),
4492 plt
->contents
+ h
->plt
.offset
+ abed
->plt_got_offset
);
4494 /* Fill in the entry in the global offset table, initially this
4495 points to the second part of the PLT entry. */
4496 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4497 + plt
->output_offset
4498 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4499 gotplt
->contents
+ got_offset
);
4501 /* Fill in the entry in the .rela.plt section. */
4502 rela
.r_offset
= (gotplt
->output_section
->vma
4503 + gotplt
->output_offset
4505 if (h
->dynindx
== -1
4506 || ((info
->executable
4507 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4509 && h
->type
== STT_GNU_IFUNC
))
4511 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4512 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4513 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4514 rela
.r_addend
= (h
->root
.u
.def
.value
4515 + h
->root
.u
.def
.section
->output_section
->vma
4516 + h
->root
.u
.def
.section
->output_offset
);
4517 /* R_X86_64_IRELATIVE comes last. */
4518 plt_index
= htab
->next_irelative_index
--;
4522 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4524 plt_index
= htab
->next_jump_slot_index
++;
4527 /* Don't fill PLT entry for static executables. */
4528 if (plt
== htab
->elf
.splt
)
4530 /* Put relocation index. */
4531 bfd_put_32 (output_bfd
, plt_index
,
4532 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4533 /* Put offset for jmp .PLT0. */
4534 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ abed
->plt_plt_insn_end
),
4535 plt
->contents
+ h
->plt
.offset
+ abed
->plt_plt_offset
);
4538 bed
= get_elf_backend_data (output_bfd
);
4539 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4540 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4542 if (!h
->def_regular
)
4544 /* Mark the symbol as undefined, rather than as defined in
4545 the .plt section. Leave the value if there were any
4546 relocations where pointer equality matters (this is a clue
4547 for the dynamic linker, to make function pointer
4548 comparisons work between an application and shared
4549 library), otherwise set it to zero. If a function is only
4550 called from a binary, there is no need to slow down
4551 shared libraries because of that. */
4552 sym
->st_shndx
= SHN_UNDEF
;
4553 if (!h
->pointer_equality_needed
)
4558 if (h
->got
.offset
!= (bfd_vma
) -1
4559 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4560 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4562 Elf_Internal_Rela rela
;
4564 /* This symbol has an entry in the global offset table. Set it
4566 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4569 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4570 + htab
->elf
.sgot
->output_offset
4571 + (h
->got
.offset
&~ (bfd_vma
) 1));
4573 /* If this is a static link, or it is a -Bsymbolic link and the
4574 symbol is defined locally or was forced to be local because
4575 of a version file, we just want to emit a RELATIVE reloc.
4576 The entry in the global offset table will already have been
4577 initialized in the relocate_section function. */
4579 && h
->type
== STT_GNU_IFUNC
)
4583 /* Generate R_X86_64_GLOB_DAT. */
4590 if (!h
->pointer_equality_needed
)
4593 /* For non-shared object, we can't use .got.plt, which
4594 contains the real function addres if we need pointer
4595 equality. We load the GOT entry with the PLT entry. */
4596 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4597 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4598 + plt
->output_offset
4600 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4604 else if (info
->shared
4605 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4607 if (!h
->def_regular
)
4609 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4610 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4611 rela
.r_addend
= (h
->root
.u
.def
.value
4612 + h
->root
.u
.def
.section
->output_section
->vma
4613 + h
->root
.u
.def
.section
->output_offset
);
4617 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4619 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4620 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4621 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4625 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4630 Elf_Internal_Rela rela
;
4632 /* This symbol needs a copy reloc. Set it up. */
4634 if (h
->dynindx
== -1
4635 || (h
->root
.type
!= bfd_link_hash_defined
4636 && h
->root
.type
!= bfd_link_hash_defweak
)
4637 || htab
->srelbss
== NULL
)
4640 rela
.r_offset
= (h
->root
.u
.def
.value
4641 + h
->root
.u
.def
.section
->output_section
->vma
4642 + h
->root
.u
.def
.section
->output_offset
);
4643 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4645 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4651 /* Finish up local dynamic symbol handling. We set the contents of
4652 various dynamic sections here. */
4655 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4657 struct elf_link_hash_entry
*h
4658 = (struct elf_link_hash_entry
*) *slot
;
4659 struct bfd_link_info
*info
4660 = (struct bfd_link_info
*) inf
;
4662 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4666 /* Used to decide how to sort relocs in an optimal manner for the
4667 dynamic linker, before writing them out. */
4669 static enum elf_reloc_type_class
4670 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4671 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4672 const Elf_Internal_Rela
*rela
)
4674 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4676 case R_X86_64_RELATIVE
:
4677 case R_X86_64_RELATIVE64
:
4678 return reloc_class_relative
;
4679 case R_X86_64_JUMP_SLOT
:
4680 return reloc_class_plt
;
4682 return reloc_class_copy
;
4684 return reloc_class_normal
;
4688 /* Finish up the dynamic sections. */
4691 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4692 struct bfd_link_info
*info
)
4694 struct elf_x86_64_link_hash_table
*htab
;
4697 const struct elf_x86_64_backend_data
*const abed
4698 = get_elf_x86_64_backend_data (output_bfd
);
4700 htab
= elf_x86_64_hash_table (info
);
4704 dynobj
= htab
->elf
.dynobj
;
4705 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4707 if (htab
->elf
.dynamic_sections_created
)
4709 bfd_byte
*dyncon
, *dynconend
;
4710 const struct elf_backend_data
*bed
;
4711 bfd_size_type sizeof_dyn
;
4713 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4716 bed
= get_elf_backend_data (dynobj
);
4717 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4718 dyncon
= sdyn
->contents
;
4719 dynconend
= sdyn
->contents
+ sdyn
->size
;
4720 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4722 Elf_Internal_Dyn dyn
;
4725 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4733 s
= htab
->elf
.sgotplt
;
4734 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4738 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4742 s
= htab
->elf
.srelplt
->output_section
;
4743 dyn
.d_un
.d_val
= s
->size
;
4747 /* The procedure linkage table relocs (DT_JMPREL) should
4748 not be included in the overall relocs (DT_RELA).
4749 Therefore, we override the DT_RELASZ entry here to
4750 make it not include the JMPREL relocs. Since the
4751 linker script arranges for .rela.plt to follow all
4752 other relocation sections, we don't have to worry
4753 about changing the DT_RELA entry. */
4754 if (htab
->elf
.srelplt
!= NULL
)
4756 s
= htab
->elf
.srelplt
->output_section
;
4757 dyn
.d_un
.d_val
-= s
->size
;
4761 case DT_TLSDESC_PLT
:
4763 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4764 + htab
->tlsdesc_plt
;
4767 case DT_TLSDESC_GOT
:
4769 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4770 + htab
->tlsdesc_got
;
4774 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4777 /* Fill in the special first entry in the procedure linkage table. */
4778 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4780 /* Fill in the first entry in the procedure linkage table. */
4781 memcpy (htab
->elf
.splt
->contents
,
4782 abed
->plt0_entry
, abed
->plt_entry_size
);
4783 /* Add offset for pushq GOT+8(%rip), since the instruction
4784 uses 6 bytes subtract this value. */
4785 bfd_put_32 (output_bfd
,
4786 (htab
->elf
.sgotplt
->output_section
->vma
4787 + htab
->elf
.sgotplt
->output_offset
4789 - htab
->elf
.splt
->output_section
->vma
4790 - htab
->elf
.splt
->output_offset
4792 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
4793 /* Add offset for the PC-relative instruction accessing GOT+16,
4794 subtracting the offset to the end of that instruction. */
4795 bfd_put_32 (output_bfd
,
4796 (htab
->elf
.sgotplt
->output_section
->vma
4797 + htab
->elf
.sgotplt
->output_offset
4799 - htab
->elf
.splt
->output_section
->vma
4800 - htab
->elf
.splt
->output_offset
4801 - abed
->plt0_got2_insn_end
),
4802 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
4804 elf_section_data (htab
->elf
.splt
->output_section
)
4805 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
4807 if (htab
->tlsdesc_plt
)
4809 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4810 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4812 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4813 abed
->plt0_entry
, abed
->plt_entry_size
);
4815 /* Add offset for pushq GOT+8(%rip), since the
4816 instruction uses 6 bytes subtract this value. */
4817 bfd_put_32 (output_bfd
,
4818 (htab
->elf
.sgotplt
->output_section
->vma
4819 + htab
->elf
.sgotplt
->output_offset
4821 - htab
->elf
.splt
->output_section
->vma
4822 - htab
->elf
.splt
->output_offset
4825 htab
->elf
.splt
->contents
4826 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
4827 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4828 where TGD stands for htab->tlsdesc_got, subtracting the offset
4829 to the end of that instruction. */
4830 bfd_put_32 (output_bfd
,
4831 (htab
->elf
.sgot
->output_section
->vma
4832 + htab
->elf
.sgot
->output_offset
4834 - htab
->elf
.splt
->output_section
->vma
4835 - htab
->elf
.splt
->output_offset
4837 - abed
->plt0_got2_insn_end
),
4838 htab
->elf
.splt
->contents
4839 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
4844 if (htab
->elf
.sgotplt
)
4846 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4848 (*_bfd_error_handler
)
4849 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4853 /* Fill in the first three entries in the global offset table. */
4854 if (htab
->elf
.sgotplt
->size
> 0)
4856 /* Set the first entry in the global offset table to the address of
4857 the dynamic section. */
4859 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4861 bfd_put_64 (output_bfd
,
4862 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4863 htab
->elf
.sgotplt
->contents
);
4864 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4865 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4866 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4869 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4873 /* Adjust .eh_frame for .plt section. */
4874 if (htab
->plt_eh_frame
!= NULL
4875 && htab
->plt_eh_frame
->contents
!= NULL
)
4877 if (htab
->elf
.splt
!= NULL
4878 && htab
->elf
.splt
->size
!= 0
4879 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
4880 && htab
->elf
.splt
->output_section
!= NULL
4881 && htab
->plt_eh_frame
->output_section
!= NULL
)
4883 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
4884 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
4885 + htab
->plt_eh_frame
->output_offset
4886 + PLT_FDE_START_OFFSET
;
4887 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
4888 htab
->plt_eh_frame
->contents
4889 + PLT_FDE_START_OFFSET
);
4891 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4893 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
4895 htab
->plt_eh_frame
->contents
))
4900 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4901 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4904 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4905 htab_traverse (htab
->loc_hash_table
,
4906 elf_x86_64_finish_local_dynamic_symbol
,
4912 /* Return address for Ith PLT stub in section PLT, for relocation REL
4913 or (bfd_vma) -1 if it should not be included. */
4916 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4917 const arelent
*rel ATTRIBUTE_UNUSED
)
4919 return plt
->vma
+ (i
+ 1) * GET_PLT_ENTRY_SIZE (plt
->owner
);
4922 /* Handle an x86-64 specific section when reading an object file. This
4923 is called when elfcode.h finds a section with an unknown type. */
4926 elf_x86_64_section_from_shdr (bfd
*abfd
,
4927 Elf_Internal_Shdr
*hdr
,
4931 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4934 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4940 /* Hook called by the linker routine which adds symbols from an object
4941 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4945 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4946 struct bfd_link_info
*info
,
4947 Elf_Internal_Sym
*sym
,
4948 const char **namep ATTRIBUTE_UNUSED
,
4949 flagword
*flagsp ATTRIBUTE_UNUSED
,
4955 switch (sym
->st_shndx
)
4957 case SHN_X86_64_LCOMMON
:
4958 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4961 lcomm
= bfd_make_section_with_flags (abfd
,
4965 | SEC_LINKER_CREATED
));
4968 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
4971 *valp
= sym
->st_size
;
4975 if ((abfd
->flags
& DYNAMIC
) == 0
4976 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
4977 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
4978 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
4984 /* Given a BFD section, try to locate the corresponding ELF section
4988 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4989 asection
*sec
, int *index_return
)
4991 if (sec
== &_bfd_elf_large_com_section
)
4993 *index_return
= SHN_X86_64_LCOMMON
;
4999 /* Process a symbol. */
5002 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5005 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5007 switch (elfsym
->internal_elf_sym
.st_shndx
)
5009 case SHN_X86_64_LCOMMON
:
5010 asym
->section
= &_bfd_elf_large_com_section
;
5011 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5012 /* Common symbol doesn't set BSF_GLOBAL. */
5013 asym
->flags
&= ~BSF_GLOBAL
;
5019 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5021 return (sym
->st_shndx
== SHN_COMMON
5022 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5026 elf_x86_64_common_section_index (asection
*sec
)
5028 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5031 return SHN_X86_64_LCOMMON
;
5035 elf_x86_64_common_section (asection
*sec
)
5037 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5038 return bfd_com_section_ptr
;
5040 return &_bfd_elf_large_com_section
;
5044 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5045 const Elf_Internal_Sym
*sym
,
5050 const asection
*oldsec
)
5052 /* A normal common symbol and a large common symbol result in a
5053 normal common symbol. We turn the large common symbol into a
5056 && h
->root
.type
== bfd_link_hash_common
5058 && bfd_is_com_section (*psec
)
5061 if (sym
->st_shndx
== SHN_COMMON
5062 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5064 h
->root
.u
.c
.p
->section
5065 = bfd_make_section_old_way (oldbfd
, "COMMON");
5066 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5068 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5069 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5070 *psec
= bfd_com_section_ptr
;
5077 elf_x86_64_additional_program_headers (bfd
*abfd
,
5078 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5083 /* Check to see if we need a large readonly segment. */
5084 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5085 if (s
&& (s
->flags
& SEC_LOAD
))
5088 /* Check to see if we need a large data segment. Since .lbss sections
5089 is placed right after the .bss section, there should be no need for
5090 a large data segment just because of .lbss. */
5091 s
= bfd_get_section_by_name (abfd
, ".ldata");
5092 if (s
&& (s
->flags
& SEC_LOAD
))
5098 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5101 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5103 if (h
->plt
.offset
!= (bfd_vma
) -1
5105 && !h
->pointer_equality_needed
)
5108 return _bfd_elf_hash_symbol (h
);
5111 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5114 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5115 const bfd_target
*output
)
5117 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5118 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5119 && _bfd_elf_relocs_compatible (input
, output
));
5122 static const struct bfd_elf_special_section
5123 elf_x86_64_special_sections
[]=
5125 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5126 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5127 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5128 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5129 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5130 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5131 { NULL
, 0, 0, 0, 0 }
5134 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5135 #define TARGET_LITTLE_NAME "elf64-x86-64"
5136 #define ELF_ARCH bfd_arch_i386
5137 #define ELF_TARGET_ID X86_64_ELF_DATA
5138 #define ELF_MACHINE_CODE EM_X86_64
5139 #define ELF_MAXPAGESIZE 0x200000
5140 #define ELF_MINPAGESIZE 0x1000
5141 #define ELF_COMMONPAGESIZE 0x1000
5143 #define elf_backend_can_gc_sections 1
5144 #define elf_backend_can_refcount 1
5145 #define elf_backend_want_got_plt 1
5146 #define elf_backend_plt_readonly 1
5147 #define elf_backend_want_plt_sym 0
5148 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5149 #define elf_backend_rela_normal 1
5150 #define elf_backend_plt_alignment 4
5152 #define elf_info_to_howto elf_x86_64_info_to_howto
5154 #define bfd_elf64_bfd_link_hash_table_create \
5155 elf_x86_64_link_hash_table_create
5156 #define bfd_elf64_bfd_link_hash_table_free \
5157 elf_x86_64_link_hash_table_free
5158 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5159 #define bfd_elf64_bfd_reloc_name_lookup \
5160 elf_x86_64_reloc_name_lookup
5162 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5163 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5164 #define elf_backend_check_relocs elf_x86_64_check_relocs
5165 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5166 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5167 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5168 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5169 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5170 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5171 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5172 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5174 #define elf_backend_write_core_note elf_x86_64_write_core_note
5176 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5177 #define elf_backend_relocate_section elf_x86_64_relocate_section
5178 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5179 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5180 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5181 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5182 #define elf_backend_object_p elf64_x86_64_elf_object_p
5183 #define bfd_elf64_mkobject elf_x86_64_mkobject
5185 #define elf_backend_section_from_shdr \
5186 elf_x86_64_section_from_shdr
5188 #define elf_backend_section_from_bfd_section \
5189 elf_x86_64_elf_section_from_bfd_section
5190 #define elf_backend_add_symbol_hook \
5191 elf_x86_64_add_symbol_hook
5192 #define elf_backend_symbol_processing \
5193 elf_x86_64_symbol_processing
5194 #define elf_backend_common_section_index \
5195 elf_x86_64_common_section_index
5196 #define elf_backend_common_section \
5197 elf_x86_64_common_section
5198 #define elf_backend_common_definition \
5199 elf_x86_64_common_definition
5200 #define elf_backend_merge_symbol \
5201 elf_x86_64_merge_symbol
5202 #define elf_backend_special_sections \
5203 elf_x86_64_special_sections
5204 #define elf_backend_additional_program_headers \
5205 elf_x86_64_additional_program_headers
5206 #define elf_backend_hash_symbol \
5207 elf_x86_64_hash_symbol
5209 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5211 #include "elf64-target.h"
5213 /* FreeBSD support. */
5215 #undef TARGET_LITTLE_SYM
5216 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5217 #undef TARGET_LITTLE_NAME
5218 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5221 #define ELF_OSABI ELFOSABI_FREEBSD
5224 #define elf64_bed elf64_x86_64_fbsd_bed
5226 #include "elf64-target.h"
5228 /* Solaris 2 support. */
5230 #undef TARGET_LITTLE_SYM
5231 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5232 #undef TARGET_LITTLE_NAME
5233 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5235 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5236 objects won't be recognized. */
5240 #define elf64_bed elf64_x86_64_sol2_bed
5242 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5244 #undef elf_backend_static_tls_alignment
5245 #define elf_backend_static_tls_alignment 16
5247 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5249 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5251 #undef elf_backend_want_plt_sym
5252 #define elf_backend_want_plt_sym 1
5254 #include "elf64-target.h"
5256 /* Native Client support. */
5258 #undef TARGET_LITTLE_SYM
5259 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5260 #undef TARGET_LITTLE_NAME
5261 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5263 #define elf64_bed elf64_x86_64_nacl_bed
5265 #undef ELF_MAXPAGESIZE
5266 #undef ELF_MINPAGESIZE
5267 #undef ELF_COMMONPAGESIZE
5268 #define ELF_MAXPAGESIZE 0x10000
5269 #define ELF_MINPAGESIZE 0x10000
5270 #define ELF_COMMONPAGESIZE 0x10000
5272 /* Restore defaults. */
5274 #undef elf_backend_static_tls_alignment
5275 #undef elf_backend_want_plt_sym
5276 #define elf_backend_want_plt_sym 0
5278 /* NaCl uses substantially different PLT entries for the same effects. */
5280 #undef elf_backend_plt_alignment
5281 #define elf_backend_plt_alignment 5
5282 #define NACL_PLT_ENTRY_SIZE 64
5283 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5285 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5287 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5288 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5289 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5290 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5291 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5293 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5294 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5296 /* 32 bytes of nop to pad out to the standard size. */
5297 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5298 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5299 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5300 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5301 0x66, /* excess data32 prefix */
5305 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5307 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5308 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5309 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5310 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5312 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5313 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5314 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5316 /* Lazy GOT entries point here (32-byte aligned). */
5317 0x68, /* pushq immediate */
5318 0, 0, 0, 0, /* replaced with index into relocation table. */
5319 0xe9, /* jmp relative */
5320 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5322 /* 22 bytes of nop to pad out to the standard size. */
5323 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5324 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5325 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5328 /* .eh_frame covering the .plt section. */
5330 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5332 #if (PLT_CIE_LENGTH != 20 \
5333 || PLT_FDE_LENGTH != 36 \
5334 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5335 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5336 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5338 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5339 0, 0, 0, 0, /* CIE ID */
5340 1, /* CIE version */
5341 'z', 'R', 0, /* Augmentation string */
5342 1, /* Code alignment factor */
5343 0x78, /* Data alignment factor */
5344 16, /* Return address column */
5345 1, /* Augmentation size */
5346 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5347 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5348 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5349 DW_CFA_nop
, DW_CFA_nop
,
5351 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5352 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5353 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5354 0, 0, 0, 0, /* .plt size goes here */
5355 0, /* Augmentation size */
5356 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5357 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5358 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5359 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5360 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5361 13, /* Block length */
5362 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5363 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5364 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5365 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5366 DW_CFA_nop
, DW_CFA_nop
5369 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5371 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5372 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5373 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5374 2, /* plt0_got1_offset */
5375 9, /* plt0_got2_offset */
5376 13, /* plt0_got2_insn_end */
5377 3, /* plt_got_offset */
5378 33, /* plt_reloc_offset */
5379 38, /* plt_plt_offset */
5380 7, /* plt_got_insn_size */
5381 42, /* plt_plt_insn_end */
5382 32, /* plt_lazy_offset */
5383 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5384 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5387 #undef elf_backend_arch_data
5388 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5390 #undef elf_backend_modify_segment_map
5391 #define elf_backend_modify_segment_map nacl_modify_segment_map
5392 #undef elf_backend_modify_program_headers
5393 #define elf_backend_modify_program_headers nacl_modify_program_headers
5395 #include "elf64-target.h"
5397 /* Native Client x32 support. */
5399 #undef TARGET_LITTLE_SYM
5400 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5401 #undef TARGET_LITTLE_NAME
5402 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5404 #define elf32_bed elf32_x86_64_nacl_bed
5406 #define bfd_elf32_bfd_link_hash_table_create \
5407 elf_x86_64_link_hash_table_create
5408 #define bfd_elf32_bfd_link_hash_table_free \
5409 elf_x86_64_link_hash_table_free
5410 #define bfd_elf32_bfd_reloc_type_lookup \
5411 elf_x86_64_reloc_type_lookup
5412 #define bfd_elf32_bfd_reloc_name_lookup \
5413 elf_x86_64_reloc_name_lookup
5414 #define bfd_elf32_mkobject \
5417 #undef elf_backend_object_p
5418 #define elf_backend_object_p \
5419 elf32_x86_64_elf_object_p
5421 #undef elf_backend_bfd_from_remote_memory
5422 #define elf_backend_bfd_from_remote_memory \
5423 _bfd_elf32_bfd_from_remote_memory
5425 #undef elf_backend_size_info
5426 #define elf_backend_size_info \
5427 _bfd_elf32_size_info
5429 #include "elf32-target.h"
5431 /* Restore defaults. */
5432 #undef elf_backend_object_p
5433 #define elf_backend_object_p elf64_x86_64_elf_object_p
5434 #undef elf_backend_bfd_from_remote_memory
5435 #undef elf_backend_size_info
5436 #undef elf_backend_modify_segment_map
5437 #undef elf_backend_modify_program_headers
5439 /* Intel L1OM support. */
5442 elf64_l1om_elf_object_p (bfd
*abfd
)
5444 /* Set the right machine number for an L1OM elf64 file. */
5445 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
5449 #undef TARGET_LITTLE_SYM
5450 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5451 #undef TARGET_LITTLE_NAME
5452 #define TARGET_LITTLE_NAME "elf64-l1om"
5454 #define ELF_ARCH bfd_arch_l1om
5456 #undef ELF_MACHINE_CODE
5457 #define ELF_MACHINE_CODE EM_L1OM
5462 #define elf64_bed elf64_l1om_bed
5464 #undef elf_backend_object_p
5465 #define elf_backend_object_p elf64_l1om_elf_object_p
5467 /* Restore defaults. */
5468 #undef ELF_MAXPAGESIZE
5469 #undef ELF_MINPAGESIZE
5470 #undef ELF_COMMONPAGESIZE
5471 #define ELF_MAXPAGESIZE 0x200000
5472 #define ELF_MINPAGESIZE 0x1000
5473 #define ELF_COMMONPAGESIZE 0x1000
5474 #undef elf_backend_plt_alignment
5475 #define elf_backend_plt_alignment 4
5476 #undef elf_backend_arch_data
5477 #define elf_backend_arch_data &elf_x86_64_arch_bed
5479 #include "elf64-target.h"
5481 /* FreeBSD L1OM support. */
5483 #undef TARGET_LITTLE_SYM
5484 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5485 #undef TARGET_LITTLE_NAME
5486 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5489 #define ELF_OSABI ELFOSABI_FREEBSD
5492 #define elf64_bed elf64_l1om_fbsd_bed
5494 #include "elf64-target.h"
5496 /* Intel K1OM support. */
5499 elf64_k1om_elf_object_p (bfd
*abfd
)
5501 /* Set the right machine number for an K1OM elf64 file. */
5502 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
5506 #undef TARGET_LITTLE_SYM
5507 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5508 #undef TARGET_LITTLE_NAME
5509 #define TARGET_LITTLE_NAME "elf64-k1om"
5511 #define ELF_ARCH bfd_arch_k1om
5513 #undef ELF_MACHINE_CODE
5514 #define ELF_MACHINE_CODE EM_K1OM
5519 #define elf64_bed elf64_k1om_bed
5521 #undef elf_backend_object_p
5522 #define elf_backend_object_p elf64_k1om_elf_object_p
5524 #undef elf_backend_static_tls_alignment
5526 #undef elf_backend_want_plt_sym
5527 #define elf_backend_want_plt_sym 0
5529 #include "elf64-target.h"
5531 /* FreeBSD K1OM support. */
5533 #undef TARGET_LITTLE_SYM
5534 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5535 #undef TARGET_LITTLE_NAME
5536 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5539 #define ELF_OSABI ELFOSABI_FREEBSD
5542 #define elf64_bed elf64_k1om_fbsd_bed
5544 #include "elf64-target.h"
5546 /* 32bit x86-64 support. */
5548 #undef TARGET_LITTLE_SYM
5549 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5550 #undef TARGET_LITTLE_NAME
5551 #define TARGET_LITTLE_NAME "elf32-x86-64"
5555 #define ELF_ARCH bfd_arch_i386
5557 #undef ELF_MACHINE_CODE
5558 #define ELF_MACHINE_CODE EM_X86_64
5562 #undef elf_backend_object_p
5563 #define elf_backend_object_p \
5564 elf32_x86_64_elf_object_p
5566 #undef elf_backend_bfd_from_remote_memory
5567 #define elf_backend_bfd_from_remote_memory \
5568 _bfd_elf32_bfd_from_remote_memory
5570 #undef elf_backend_size_info
5571 #define elf_backend_size_info \
5572 _bfd_elf32_size_info
5574 #include "elf32-target.h"