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_malloc (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
->plt_eh_frame
= NULL
;
907 ret
->sym_cache
.abfd
= NULL
;
908 ret
->tlsdesc_plt
= 0;
909 ret
->tlsdesc_got
= 0;
910 ret
->tls_ld_got
.refcount
= 0;
911 ret
->sgotplt_jump_table_size
= 0;
912 ret
->tls_module_base
= NULL
;
913 ret
->next_jump_slot_index
= 0;
914 ret
->next_irelative_index
= 0;
918 ret
->r_info
= elf64_r_info
;
919 ret
->r_sym
= elf64_r_sym
;
920 ret
->pointer_r_type
= R_X86_64_64
;
921 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
922 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
926 ret
->r_info
= elf32_r_info
;
927 ret
->r_sym
= elf32_r_sym
;
928 ret
->pointer_r_type
= R_X86_64_32
;
929 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
930 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
933 ret
->loc_hash_table
= htab_try_create (1024,
934 elf_x86_64_local_htab_hash
,
935 elf_x86_64_local_htab_eq
,
937 ret
->loc_hash_memory
= objalloc_create ();
938 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
944 return &ret
->elf
.root
;
947 /* Destroy an X86-64 ELF linker hash table. */
950 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
952 struct elf_x86_64_link_hash_table
*htab
953 = (struct elf_x86_64_link_hash_table
*) hash
;
955 if (htab
->loc_hash_table
)
956 htab_delete (htab
->loc_hash_table
);
957 if (htab
->loc_hash_memory
)
958 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
959 _bfd_generic_link_hash_table_free (hash
);
962 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
963 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
967 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
968 struct bfd_link_info
*info
)
970 struct elf_x86_64_link_hash_table
*htab
;
972 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
975 htab
= elf_x86_64_hash_table (info
);
979 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
981 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
984 || (!info
->shared
&& !htab
->srelbss
))
987 if (!info
->no_ld_generated_unwind_info
988 && htab
->plt_eh_frame
== NULL
989 && htab
->elf
.splt
!= NULL
)
991 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
992 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
993 | SEC_LINKER_CREATED
);
995 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
996 if (htab
->plt_eh_frame
== NULL
997 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1003 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1006 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1007 struct elf_link_hash_entry
*dir
,
1008 struct elf_link_hash_entry
*ind
)
1010 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1012 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1013 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1015 if (eind
->dyn_relocs
!= NULL
)
1017 if (edir
->dyn_relocs
!= NULL
)
1019 struct elf_dyn_relocs
**pp
;
1020 struct elf_dyn_relocs
*p
;
1022 /* Add reloc counts against the indirect sym to the direct sym
1023 list. Merge any entries against the same section. */
1024 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1026 struct elf_dyn_relocs
*q
;
1028 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1029 if (q
->sec
== p
->sec
)
1031 q
->pc_count
+= p
->pc_count
;
1032 q
->count
+= p
->count
;
1039 *pp
= edir
->dyn_relocs
;
1042 edir
->dyn_relocs
= eind
->dyn_relocs
;
1043 eind
->dyn_relocs
= NULL
;
1046 if (ind
->root
.type
== bfd_link_hash_indirect
1047 && dir
->got
.refcount
<= 0)
1049 edir
->tls_type
= eind
->tls_type
;
1050 eind
->tls_type
= GOT_UNKNOWN
;
1053 if (ELIMINATE_COPY_RELOCS
1054 && ind
->root
.type
!= bfd_link_hash_indirect
1055 && dir
->dynamic_adjusted
)
1057 /* If called to transfer flags for a weakdef during processing
1058 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1059 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1060 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1061 dir
->ref_regular
|= ind
->ref_regular
;
1062 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1063 dir
->needs_plt
|= ind
->needs_plt
;
1064 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1067 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1071 elf64_x86_64_elf_object_p (bfd
*abfd
)
1073 /* Set the right machine number for an x86-64 elf64 file. */
1074 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1079 elf32_x86_64_elf_object_p (bfd
*abfd
)
1081 /* Set the right machine number for an x86-64 elf32 file. */
1082 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1086 /* Return TRUE if the TLS access code sequence support transition
1090 elf_x86_64_check_tls_transition (bfd
*abfd
,
1091 struct bfd_link_info
*info
,
1094 Elf_Internal_Shdr
*symtab_hdr
,
1095 struct elf_link_hash_entry
**sym_hashes
,
1096 unsigned int r_type
,
1097 const Elf_Internal_Rela
*rel
,
1098 const Elf_Internal_Rela
*relend
)
1101 unsigned long r_symndx
;
1102 struct elf_link_hash_entry
*h
;
1104 struct elf_x86_64_link_hash_table
*htab
;
1106 /* Get the section contents. */
1107 if (contents
== NULL
)
1109 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1110 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1113 /* FIXME: How to better handle error condition? */
1114 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1117 /* Cache the section contents for elf_link_input_bfd. */
1118 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1122 htab
= elf_x86_64_hash_table (info
);
1123 offset
= rel
->r_offset
;
1126 case R_X86_64_TLSGD
:
1127 case R_X86_64_TLSLD
:
1128 if ((rel
+ 1) >= relend
)
1131 if (r_type
== R_X86_64_TLSGD
)
1133 /* Check transition from GD access model. For 64bit, only
1134 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1135 .word 0x6666; rex64; call __tls_get_addr
1136 can transit to different access model. For 32bit, only
1137 leaq foo@tlsgd(%rip), %rdi
1138 .word 0x6666; rex64; call __tls_get_addr
1139 can transit to different access model. */
1141 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1142 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1144 if ((offset
+ 12) > sec
->size
1145 || memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1148 if (ABI_64_P (abfd
))
1151 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1157 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1163 /* Check transition from LD access model. Only
1164 leaq foo@tlsld(%rip), %rdi;
1166 can transit to different access model. */
1168 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1170 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1173 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0
1174 || 0xe8 != *(contents
+ offset
+ 4))
1178 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1179 if (r_symndx
< symtab_hdr
->sh_info
)
1182 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1183 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1184 may be versioned. */
1186 && h
->root
.root
.string
!= NULL
1187 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1188 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
1189 && (strncmp (h
->root
.root
.string
,
1190 "__tls_get_addr", 14) == 0));
1192 case R_X86_64_GOTTPOFF
:
1193 /* Check transition from IE access model:
1194 mov foo@gottpoff(%rip), %reg
1195 add foo@gottpoff(%rip), %reg
1198 /* Check REX prefix first. */
1199 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1201 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1202 if (val
!= 0x48 && val
!= 0x4c)
1204 /* X32 may have 0x44 REX prefix or no REX prefix. */
1205 if (ABI_64_P (abfd
))
1211 /* X32 may not have any REX prefix. */
1212 if (ABI_64_P (abfd
))
1214 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1218 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1219 if (val
!= 0x8b && val
!= 0x03)
1222 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1223 return (val
& 0xc7) == 5;
1225 case R_X86_64_GOTPC32_TLSDESC
:
1226 /* Check transition from GDesc access model:
1227 leaq x@tlsdesc(%rip), %rax
1229 Make sure it's a leaq adding rip to a 32-bit offset
1230 into any register, although it's probably almost always
1233 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1236 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1237 if ((val
& 0xfb) != 0x48)
1240 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1243 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1244 return (val
& 0xc7) == 0x05;
1246 case R_X86_64_TLSDESC_CALL
:
1247 /* Check transition from GDesc access model:
1248 call *x@tlsdesc(%rax)
1250 if (offset
+ 2 <= sec
->size
)
1252 /* Make sure that it's a call *x@tlsdesc(%rax). */
1253 static const unsigned char call
[] = { 0xff, 0x10 };
1254 return memcmp (contents
+ offset
, call
, 2) == 0;
1264 /* Return TRUE if the TLS access transition is OK or no transition
1265 will be performed. Update R_TYPE if there is a transition. */
1268 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1269 asection
*sec
, bfd_byte
*contents
,
1270 Elf_Internal_Shdr
*symtab_hdr
,
1271 struct elf_link_hash_entry
**sym_hashes
,
1272 unsigned int *r_type
, int tls_type
,
1273 const Elf_Internal_Rela
*rel
,
1274 const Elf_Internal_Rela
*relend
,
1275 struct elf_link_hash_entry
*h
,
1276 unsigned long r_symndx
)
1278 unsigned int from_type
= *r_type
;
1279 unsigned int to_type
= from_type
;
1280 bfd_boolean check
= TRUE
;
1282 /* Skip TLS transition for functions. */
1284 && (h
->type
== STT_FUNC
1285 || h
->type
== STT_GNU_IFUNC
))
1290 case R_X86_64_TLSGD
:
1291 case R_X86_64_GOTPC32_TLSDESC
:
1292 case R_X86_64_TLSDESC_CALL
:
1293 case R_X86_64_GOTTPOFF
:
1294 if (info
->executable
)
1297 to_type
= R_X86_64_TPOFF32
;
1299 to_type
= R_X86_64_GOTTPOFF
;
1302 /* When we are called from elf_x86_64_relocate_section,
1303 CONTENTS isn't NULL and there may be additional transitions
1304 based on TLS_TYPE. */
1305 if (contents
!= NULL
)
1307 unsigned int new_to_type
= to_type
;
1309 if (info
->executable
1312 && tls_type
== GOT_TLS_IE
)
1313 new_to_type
= R_X86_64_TPOFF32
;
1315 if (to_type
== R_X86_64_TLSGD
1316 || to_type
== R_X86_64_GOTPC32_TLSDESC
1317 || to_type
== R_X86_64_TLSDESC_CALL
)
1319 if (tls_type
== GOT_TLS_IE
)
1320 new_to_type
= R_X86_64_GOTTPOFF
;
1323 /* We checked the transition before when we were called from
1324 elf_x86_64_check_relocs. We only want to check the new
1325 transition which hasn't been checked before. */
1326 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1327 to_type
= new_to_type
;
1332 case R_X86_64_TLSLD
:
1333 if (info
->executable
)
1334 to_type
= R_X86_64_TPOFF32
;
1341 /* Return TRUE if there is no transition. */
1342 if (from_type
== to_type
)
1345 /* Check if the transition can be performed. */
1347 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1348 symtab_hdr
, sym_hashes
,
1349 from_type
, rel
, relend
))
1351 reloc_howto_type
*from
, *to
;
1354 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1355 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1358 name
= h
->root
.root
.string
;
1361 struct elf_x86_64_link_hash_table
*htab
;
1363 htab
= elf_x86_64_hash_table (info
);
1368 Elf_Internal_Sym
*isym
;
1370 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1372 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1376 (*_bfd_error_handler
)
1377 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1378 "in section `%A' failed"),
1379 abfd
, sec
, from
->name
, to
->name
, name
,
1380 (unsigned long) rel
->r_offset
);
1381 bfd_set_error (bfd_error_bad_value
);
1389 /* Look through the relocs for a section during the first phase, and
1390 calculate needed space in the global offset table, procedure
1391 linkage table, and dynamic reloc sections. */
1394 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1396 const Elf_Internal_Rela
*relocs
)
1398 struct elf_x86_64_link_hash_table
*htab
;
1399 Elf_Internal_Shdr
*symtab_hdr
;
1400 struct elf_link_hash_entry
**sym_hashes
;
1401 const Elf_Internal_Rela
*rel
;
1402 const Elf_Internal_Rela
*rel_end
;
1405 if (info
->relocatable
)
1408 BFD_ASSERT (is_x86_64_elf (abfd
));
1410 htab
= elf_x86_64_hash_table (info
);
1414 symtab_hdr
= &elf_symtab_hdr (abfd
);
1415 sym_hashes
= elf_sym_hashes (abfd
);
1419 rel_end
= relocs
+ sec
->reloc_count
;
1420 for (rel
= relocs
; rel
< rel_end
; rel
++)
1422 unsigned int r_type
;
1423 unsigned long r_symndx
;
1424 struct elf_link_hash_entry
*h
;
1425 Elf_Internal_Sym
*isym
;
1427 bfd_boolean size_reloc
;
1429 r_symndx
= htab
->r_sym (rel
->r_info
);
1430 r_type
= ELF32_R_TYPE (rel
->r_info
);
1432 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1434 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1439 if (r_symndx
< symtab_hdr
->sh_info
)
1441 /* A local symbol. */
1442 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1447 /* Check relocation against local STT_GNU_IFUNC symbol. */
1448 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1450 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1455 /* Fake a STT_GNU_IFUNC symbol. */
1456 h
->type
= STT_GNU_IFUNC
;
1459 h
->forced_local
= 1;
1460 h
->root
.type
= bfd_link_hash_defined
;
1468 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1469 while (h
->root
.type
== bfd_link_hash_indirect
1470 || h
->root
.type
== bfd_link_hash_warning
)
1471 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1474 /* Check invalid x32 relocations. */
1475 if (!ABI_64_P (abfd
))
1481 case R_X86_64_DTPOFF64
:
1482 case R_X86_64_TPOFF64
:
1484 case R_X86_64_GOTOFF64
:
1485 case R_X86_64_GOT64
:
1486 case R_X86_64_GOTPCREL64
:
1487 case R_X86_64_GOTPC64
:
1488 case R_X86_64_GOTPLT64
:
1489 case R_X86_64_PLTOFF64
:
1492 name
= h
->root
.root
.string
;
1494 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1496 (*_bfd_error_handler
)
1497 (_("%B: relocation %s against symbol `%s' isn't "
1498 "supported in x32 mode"), abfd
,
1499 x86_64_elf_howto_table
[r_type
].name
, name
);
1500 bfd_set_error (bfd_error_bad_value
);
1508 /* Create the ifunc sections for static executables. If we
1509 never see an indirect function symbol nor we are building
1510 a static executable, those sections will be empty and
1511 won't appear in output. */
1522 case R_X86_64_PLT32
:
1523 case R_X86_64_GOTPCREL
:
1524 case R_X86_64_GOTPCREL64
:
1525 if (htab
->elf
.dynobj
== NULL
)
1526 htab
->elf
.dynobj
= abfd
;
1527 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1532 /* It is referenced by a non-shared object. */
1536 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1537 symtab_hdr
, sym_hashes
,
1538 &r_type
, GOT_UNKNOWN
,
1539 rel
, rel_end
, h
, r_symndx
))
1544 case R_X86_64_TLSLD
:
1545 htab
->tls_ld_got
.refcount
+= 1;
1548 case R_X86_64_TPOFF32
:
1549 if (!info
->executable
&& ABI_64_P (abfd
))
1552 name
= h
->root
.root
.string
;
1554 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1556 (*_bfd_error_handler
)
1557 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1559 x86_64_elf_howto_table
[r_type
].name
, name
);
1560 bfd_set_error (bfd_error_bad_value
);
1565 case R_X86_64_GOTTPOFF
:
1566 if (!info
->executable
)
1567 info
->flags
|= DF_STATIC_TLS
;
1570 case R_X86_64_GOT32
:
1571 case R_X86_64_GOTPCREL
:
1572 case R_X86_64_TLSGD
:
1573 case R_X86_64_GOT64
:
1574 case R_X86_64_GOTPCREL64
:
1575 case R_X86_64_GOTPLT64
:
1576 case R_X86_64_GOTPC32_TLSDESC
:
1577 case R_X86_64_TLSDESC_CALL
:
1578 /* This symbol requires a global offset table entry. */
1580 int tls_type
, old_tls_type
;
1584 default: tls_type
= GOT_NORMAL
; break;
1585 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1586 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1587 case R_X86_64_GOTPC32_TLSDESC
:
1588 case R_X86_64_TLSDESC_CALL
:
1589 tls_type
= GOT_TLS_GDESC
; break;
1594 if (r_type
== R_X86_64_GOTPLT64
)
1596 /* This relocation indicates that we also need
1597 a PLT entry, as this is a function. We don't need
1598 a PLT entry for local symbols. */
1600 h
->plt
.refcount
+= 1;
1602 h
->got
.refcount
+= 1;
1603 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1607 bfd_signed_vma
*local_got_refcounts
;
1609 /* This is a global offset table entry for a local symbol. */
1610 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1611 if (local_got_refcounts
== NULL
)
1615 size
= symtab_hdr
->sh_info
;
1616 size
*= sizeof (bfd_signed_vma
)
1617 + sizeof (bfd_vma
) + sizeof (char);
1618 local_got_refcounts
= ((bfd_signed_vma
*)
1619 bfd_zalloc (abfd
, size
));
1620 if (local_got_refcounts
== NULL
)
1622 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1623 elf_x86_64_local_tlsdesc_gotent (abfd
)
1624 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1625 elf_x86_64_local_got_tls_type (abfd
)
1626 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1628 local_got_refcounts
[r_symndx
] += 1;
1630 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1633 /* If a TLS symbol is accessed using IE at least once,
1634 there is no point to use dynamic model for it. */
1635 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1636 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1637 || tls_type
!= GOT_TLS_IE
))
1639 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1640 tls_type
= old_tls_type
;
1641 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1642 && GOT_TLS_GD_ANY_P (tls_type
))
1643 tls_type
|= old_tls_type
;
1647 name
= h
->root
.root
.string
;
1649 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1651 (*_bfd_error_handler
)
1652 (_("%B: '%s' accessed both as normal and thread local symbol"),
1654 bfd_set_error (bfd_error_bad_value
);
1659 if (old_tls_type
!= tls_type
)
1662 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1664 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1669 case R_X86_64_GOTOFF64
:
1670 case R_X86_64_GOTPC32
:
1671 case R_X86_64_GOTPC64
:
1673 if (htab
->elf
.sgot
== NULL
)
1675 if (htab
->elf
.dynobj
== NULL
)
1676 htab
->elf
.dynobj
= abfd
;
1677 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1683 case R_X86_64_PLT32
:
1684 /* This symbol requires a procedure linkage table entry. We
1685 actually build the entry in adjust_dynamic_symbol,
1686 because this might be a case of linking PIC code which is
1687 never referenced by a dynamic object, in which case we
1688 don't need to generate a procedure linkage table entry
1691 /* If this is a local symbol, we resolve it directly without
1692 creating a procedure linkage table entry. */
1697 h
->plt
.refcount
+= 1;
1700 case R_X86_64_PLTOFF64
:
1701 /* This tries to form the 'address' of a function relative
1702 to GOT. For global symbols we need a PLT entry. */
1706 h
->plt
.refcount
+= 1;
1710 case R_X86_64_SIZE32
:
1711 case R_X86_64_SIZE64
:
1716 if (!ABI_64_P (abfd
))
1721 /* Let's help debug shared library creation. These relocs
1722 cannot be used in shared libs. Don't error out for
1723 sections we don't care about, such as debug sections or
1724 non-constant sections. */
1726 && (sec
->flags
& SEC_ALLOC
) != 0
1727 && (sec
->flags
& SEC_READONLY
) != 0)
1730 name
= h
->root
.root
.string
;
1732 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1733 (*_bfd_error_handler
)
1734 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1735 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1736 bfd_set_error (bfd_error_bad_value
);
1747 if (h
!= NULL
&& info
->executable
)
1749 /* If this reloc is in a read-only section, we might
1750 need a copy reloc. We can't check reliably at this
1751 stage whether the section is read-only, as input
1752 sections have not yet been mapped to output sections.
1753 Tentatively set the flag for now, and correct in
1754 adjust_dynamic_symbol. */
1757 /* We may need a .plt entry if the function this reloc
1758 refers to is in a shared lib. */
1759 h
->plt
.refcount
+= 1;
1760 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1761 h
->pointer_equality_needed
= 1;
1766 /* If we are creating a shared library, and this is a reloc
1767 against a global symbol, or a non PC relative reloc
1768 against a local symbol, then we need to copy the reloc
1769 into the shared library. However, if we are linking with
1770 -Bsymbolic, we do not need to copy a reloc against a
1771 global symbol which is defined in an object we are
1772 including in the link (i.e., DEF_REGULAR is set). At
1773 this point we have not seen all the input files, so it is
1774 possible that DEF_REGULAR is not set now but will be set
1775 later (it is never cleared). In case of a weak definition,
1776 DEF_REGULAR may be cleared later by a strong definition in
1777 a shared library. We account for that possibility below by
1778 storing information in the relocs_copied field of the hash
1779 table entry. A similar situation occurs when creating
1780 shared libraries and symbol visibility changes render the
1783 If on the other hand, we are creating an executable, we
1784 may need to keep relocations for symbols satisfied by a
1785 dynamic library if we manage to avoid copy relocs for the
1788 && (sec
->flags
& SEC_ALLOC
) != 0
1789 && (! IS_X86_64_PCREL_TYPE (r_type
)
1791 && (! SYMBOLIC_BIND (info
, h
)
1792 || h
->root
.type
== bfd_link_hash_defweak
1793 || !h
->def_regular
))))
1794 || (ELIMINATE_COPY_RELOCS
1796 && (sec
->flags
& SEC_ALLOC
) != 0
1798 && (h
->root
.type
== bfd_link_hash_defweak
1799 || !h
->def_regular
)))
1801 struct elf_dyn_relocs
*p
;
1802 struct elf_dyn_relocs
**head
;
1804 /* We must copy these reloc types into the output file.
1805 Create a reloc section in dynobj and make room for
1809 if (htab
->elf
.dynobj
== NULL
)
1810 htab
->elf
.dynobj
= abfd
;
1812 sreloc
= _bfd_elf_make_dynamic_reloc_section
1813 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1814 abfd
, /*rela?*/ TRUE
);
1820 /* If this is a global symbol, we count the number of
1821 relocations we need for this symbol. */
1824 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1828 /* Track dynamic relocs needed for local syms too.
1829 We really need local syms available to do this
1834 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1839 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1843 /* Beware of type punned pointers vs strict aliasing
1845 vpp
= &(elf_section_data (s
)->local_dynrel
);
1846 head
= (struct elf_dyn_relocs
**)vpp
;
1850 if (p
== NULL
|| p
->sec
!= sec
)
1852 bfd_size_type amt
= sizeof *p
;
1854 p
= ((struct elf_dyn_relocs
*)
1855 bfd_alloc (htab
->elf
.dynobj
, amt
));
1866 /* Count size relocation as PC-relative relocation. */
1867 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
1872 /* This relocation describes the C++ object vtable hierarchy.
1873 Reconstruct it for later use during GC. */
1874 case R_X86_64_GNU_VTINHERIT
:
1875 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1879 /* This relocation describes which C++ vtable entries are actually
1880 used. Record for later use during GC. */
1881 case R_X86_64_GNU_VTENTRY
:
1882 BFD_ASSERT (h
!= NULL
);
1884 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1896 /* Return the section that should be marked against GC for a given
1900 elf_x86_64_gc_mark_hook (asection
*sec
,
1901 struct bfd_link_info
*info
,
1902 Elf_Internal_Rela
*rel
,
1903 struct elf_link_hash_entry
*h
,
1904 Elf_Internal_Sym
*sym
)
1907 switch (ELF32_R_TYPE (rel
->r_info
))
1909 case R_X86_64_GNU_VTINHERIT
:
1910 case R_X86_64_GNU_VTENTRY
:
1914 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1917 /* Update the got entry reference counts for the section being removed. */
1920 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1922 const Elf_Internal_Rela
*relocs
)
1924 struct elf_x86_64_link_hash_table
*htab
;
1925 Elf_Internal_Shdr
*symtab_hdr
;
1926 struct elf_link_hash_entry
**sym_hashes
;
1927 bfd_signed_vma
*local_got_refcounts
;
1928 const Elf_Internal_Rela
*rel
, *relend
;
1930 if (info
->relocatable
)
1933 htab
= elf_x86_64_hash_table (info
);
1937 elf_section_data (sec
)->local_dynrel
= NULL
;
1939 symtab_hdr
= &elf_symtab_hdr (abfd
);
1940 sym_hashes
= elf_sym_hashes (abfd
);
1941 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1943 htab
= elf_x86_64_hash_table (info
);
1944 relend
= relocs
+ sec
->reloc_count
;
1945 for (rel
= relocs
; rel
< relend
; rel
++)
1947 unsigned long r_symndx
;
1948 unsigned int r_type
;
1949 struct elf_link_hash_entry
*h
= NULL
;
1951 r_symndx
= htab
->r_sym (rel
->r_info
);
1952 if (r_symndx
>= symtab_hdr
->sh_info
)
1954 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1955 while (h
->root
.type
== bfd_link_hash_indirect
1956 || h
->root
.type
== bfd_link_hash_warning
)
1957 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1961 /* A local symbol. */
1962 Elf_Internal_Sym
*isym
;
1964 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1967 /* Check relocation against local STT_GNU_IFUNC symbol. */
1969 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1971 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1979 struct elf_x86_64_link_hash_entry
*eh
;
1980 struct elf_dyn_relocs
**pp
;
1981 struct elf_dyn_relocs
*p
;
1983 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1985 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1988 /* Everything must go for SEC. */
1994 r_type
= ELF32_R_TYPE (rel
->r_info
);
1995 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1996 symtab_hdr
, sym_hashes
,
1997 &r_type
, GOT_UNKNOWN
,
1998 rel
, relend
, h
, r_symndx
))
2003 case R_X86_64_TLSLD
:
2004 if (htab
->tls_ld_got
.refcount
> 0)
2005 htab
->tls_ld_got
.refcount
-= 1;
2008 case R_X86_64_TLSGD
:
2009 case R_X86_64_GOTPC32_TLSDESC
:
2010 case R_X86_64_TLSDESC_CALL
:
2011 case R_X86_64_GOTTPOFF
:
2012 case R_X86_64_GOT32
:
2013 case R_X86_64_GOTPCREL
:
2014 case R_X86_64_GOT64
:
2015 case R_X86_64_GOTPCREL64
:
2016 case R_X86_64_GOTPLT64
:
2019 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
2020 h
->plt
.refcount
-= 1;
2021 if (h
->got
.refcount
> 0)
2022 h
->got
.refcount
-= 1;
2023 if (h
->type
== STT_GNU_IFUNC
)
2025 if (h
->plt
.refcount
> 0)
2026 h
->plt
.refcount
-= 1;
2029 else if (local_got_refcounts
!= NULL
)
2031 if (local_got_refcounts
[r_symndx
] > 0)
2032 local_got_refcounts
[r_symndx
] -= 1;
2045 case R_X86_64_SIZE32
:
2046 case R_X86_64_SIZE64
:
2048 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2052 case R_X86_64_PLT32
:
2053 case R_X86_64_PLTOFF64
:
2056 if (h
->plt
.refcount
> 0)
2057 h
->plt
.refcount
-= 1;
2069 /* Adjust a symbol defined by a dynamic object and referenced by a
2070 regular object. The current definition is in some section of the
2071 dynamic object, but we're not including those sections. We have to
2072 change the definition to something the rest of the link can
2076 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2077 struct elf_link_hash_entry
*h
)
2079 struct elf_x86_64_link_hash_table
*htab
;
2081 struct elf_x86_64_link_hash_entry
*eh
;
2082 struct elf_dyn_relocs
*p
;
2084 /* STT_GNU_IFUNC symbol must go through PLT. */
2085 if (h
->type
== STT_GNU_IFUNC
)
2087 /* All local STT_GNU_IFUNC references must be treate as local
2088 calls via local PLT. */
2090 && SYMBOL_CALLS_LOCAL (info
, h
))
2092 bfd_size_type pc_count
= 0, count
= 0;
2093 struct elf_dyn_relocs
**pp
;
2095 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2096 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2098 pc_count
+= p
->pc_count
;
2099 p
->count
-= p
->pc_count
;
2108 if (pc_count
|| count
)
2112 if (h
->plt
.refcount
<= 0)
2113 h
->plt
.refcount
= 1;
2115 h
->plt
.refcount
+= 1;
2119 if (h
->plt
.refcount
<= 0)
2121 h
->plt
.offset
= (bfd_vma
) -1;
2127 /* If this is a function, put it in the procedure linkage table. We
2128 will fill in the contents of the procedure linkage table later,
2129 when we know the address of the .got section. */
2130 if (h
->type
== STT_FUNC
2133 if (h
->plt
.refcount
<= 0
2134 || SYMBOL_CALLS_LOCAL (info
, h
)
2135 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2136 && h
->root
.type
== bfd_link_hash_undefweak
))
2138 /* This case can occur if we saw a PLT32 reloc in an input
2139 file, but the symbol was never referred to by a dynamic
2140 object, or if all references were garbage collected. In
2141 such a case, we don't actually need to build a procedure
2142 linkage table, and we can just do a PC32 reloc instead. */
2143 h
->plt
.offset
= (bfd_vma
) -1;
2150 /* It's possible that we incorrectly decided a .plt reloc was
2151 needed for an R_X86_64_PC32 reloc to a non-function sym in
2152 check_relocs. We can't decide accurately between function and
2153 non-function syms in check-relocs; Objects loaded later in
2154 the link may change h->type. So fix it now. */
2155 h
->plt
.offset
= (bfd_vma
) -1;
2157 /* If this is a weak symbol, and there is a real definition, the
2158 processor independent code will have arranged for us to see the
2159 real definition first, and we can just use the same value. */
2160 if (h
->u
.weakdef
!= NULL
)
2162 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2163 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2164 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2165 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2166 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2167 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2171 /* This is a reference to a symbol defined by a dynamic object which
2172 is not a function. */
2174 /* If we are creating a shared library, we must presume that the
2175 only references to the symbol are via the global offset table.
2176 For such cases we need not do anything here; the relocations will
2177 be handled correctly by relocate_section. */
2181 /* If there are no references to this symbol that do not use the
2182 GOT, we don't need to generate a copy reloc. */
2183 if (!h
->non_got_ref
)
2186 /* If -z nocopyreloc was given, we won't generate them either. */
2187 if (info
->nocopyreloc
)
2193 if (ELIMINATE_COPY_RELOCS
)
2195 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2196 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2198 s
= p
->sec
->output_section
;
2199 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2203 /* If we didn't find any dynamic relocs in read-only sections, then
2204 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2212 /* We must allocate the symbol in our .dynbss section, which will
2213 become part of the .bss section of the executable. There will be
2214 an entry for this symbol in the .dynsym section. The dynamic
2215 object will contain position independent code, so all references
2216 from the dynamic object to this symbol will go through the global
2217 offset table. The dynamic linker will use the .dynsym entry to
2218 determine the address it must put in the global offset table, so
2219 both the dynamic object and the regular object will refer to the
2220 same memory location for the variable. */
2222 htab
= elf_x86_64_hash_table (info
);
2226 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2227 to copy the initial value out of the dynamic object and into the
2228 runtime process image. */
2229 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2231 const struct elf_backend_data
*bed
;
2232 bed
= get_elf_backend_data (info
->output_bfd
);
2233 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2239 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2242 /* Allocate space in .plt, .got and associated reloc sections for
2246 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2248 struct bfd_link_info
*info
;
2249 struct elf_x86_64_link_hash_table
*htab
;
2250 struct elf_x86_64_link_hash_entry
*eh
;
2251 struct elf_dyn_relocs
*p
;
2252 const struct elf_backend_data
*bed
;
2253 unsigned int plt_entry_size
;
2255 if (h
->root
.type
== bfd_link_hash_indirect
)
2258 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2260 info
= (struct bfd_link_info
*) inf
;
2261 htab
= elf_x86_64_hash_table (info
);
2264 bed
= get_elf_backend_data (info
->output_bfd
);
2265 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2267 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2268 here if it is defined and referenced in a non-shared object. */
2269 if (h
->type
== STT_GNU_IFUNC
2271 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2275 else if (htab
->elf
.dynamic_sections_created
2276 && h
->plt
.refcount
> 0)
2278 /* Make sure this symbol is output as a dynamic symbol.
2279 Undefined weak syms won't yet be marked as dynamic. */
2280 if (h
->dynindx
== -1
2281 && !h
->forced_local
)
2283 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2288 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2290 asection
*s
= htab
->elf
.splt
;
2292 /* If this is the first .plt entry, make room for the special
2295 s
->size
+= plt_entry_size
;
2297 h
->plt
.offset
= s
->size
;
2299 /* If this symbol is not defined in a regular file, and we are
2300 not generating a shared library, then set the symbol to this
2301 location in the .plt. This is required to make function
2302 pointers compare as equal between the normal executable and
2303 the shared library. */
2307 h
->root
.u
.def
.section
= s
;
2308 h
->root
.u
.def
.value
= h
->plt
.offset
;
2311 /* Make room for this entry. */
2312 s
->size
+= plt_entry_size
;
2314 /* We also need to make an entry in the .got.plt section, which
2315 will be placed in the .got section by the linker script. */
2316 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2318 /* We also need to make an entry in the .rela.plt section. */
2319 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2320 htab
->elf
.srelplt
->reloc_count
++;
2324 h
->plt
.offset
= (bfd_vma
) -1;
2330 h
->plt
.offset
= (bfd_vma
) -1;
2334 eh
->tlsdesc_got
= (bfd_vma
) -1;
2336 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2337 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2338 if (h
->got
.refcount
> 0
2341 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2343 h
->got
.offset
= (bfd_vma
) -1;
2345 else if (h
->got
.refcount
> 0)
2349 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2351 /* Make sure this symbol is output as a dynamic symbol.
2352 Undefined weak syms won't yet be marked as dynamic. */
2353 if (h
->dynindx
== -1
2354 && !h
->forced_local
)
2356 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2360 if (GOT_TLS_GDESC_P (tls_type
))
2362 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2363 - elf_x86_64_compute_jump_table_size (htab
);
2364 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2365 h
->got
.offset
= (bfd_vma
) -2;
2367 if (! GOT_TLS_GDESC_P (tls_type
)
2368 || GOT_TLS_GD_P (tls_type
))
2371 h
->got
.offset
= s
->size
;
2372 s
->size
+= GOT_ENTRY_SIZE
;
2373 if (GOT_TLS_GD_P (tls_type
))
2374 s
->size
+= GOT_ENTRY_SIZE
;
2376 dyn
= htab
->elf
.dynamic_sections_created
;
2377 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2379 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2380 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2381 || tls_type
== GOT_TLS_IE
)
2382 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2383 else if (GOT_TLS_GD_P (tls_type
))
2384 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2385 else if (! GOT_TLS_GDESC_P (tls_type
)
2386 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2387 || h
->root
.type
!= bfd_link_hash_undefweak
)
2389 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2390 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2391 if (GOT_TLS_GDESC_P (tls_type
))
2393 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2394 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2398 h
->got
.offset
= (bfd_vma
) -1;
2400 if (eh
->dyn_relocs
== NULL
)
2403 /* Since pc_count for TLS symbol can only have size relocations and
2404 we always resolve size relocation against non-zero TLS symbol, we
2405 clear pc_count for non-zero TLS symbol. */
2406 if (h
->type
== STT_TLS
&& h
->size
!= 0)
2408 struct elf_dyn_relocs
**pp
;
2410 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2412 p
->count
-= p
->pc_count
;
2421 /* In the shared -Bsymbolic case, discard space allocated for
2422 dynamic pc-relative relocs against symbols which turn out to be
2423 defined in regular objects. For the normal shared case, discard
2424 space for pc-relative relocs that have become local due to symbol
2425 visibility changes. */
2429 /* Relocs that use pc_count are those that appear on a call
2430 insn, or certain REL relocs that can generated via assembly.
2431 We want calls to protected symbols to resolve directly to the
2432 function rather than going via the plt. If people want
2433 function pointer comparisons to work as expected then they
2434 should avoid writing weird assembly. */
2435 if (SYMBOL_CALLS_LOCAL (info
, h
))
2437 struct elf_dyn_relocs
**pp
;
2439 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2441 p
->count
-= p
->pc_count
;
2450 /* Also discard relocs on undefined weak syms with non-default
2452 if (eh
->dyn_relocs
!= NULL
2453 && h
->root
.type
== bfd_link_hash_undefweak
)
2455 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2456 eh
->dyn_relocs
= NULL
;
2458 /* Make sure undefined weak symbols are output as a dynamic
2460 else if (h
->dynindx
== -1
2461 && ! h
->forced_local
2462 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2467 else if (ELIMINATE_COPY_RELOCS
)
2469 /* For the non-shared case, discard space for relocs against
2470 symbols which turn out to need copy relocs or are not
2476 || (htab
->elf
.dynamic_sections_created
2477 && (h
->root
.type
== bfd_link_hash_undefweak
2478 || h
->root
.type
== bfd_link_hash_undefined
))))
2480 /* Make sure this symbol is output as a dynamic symbol.
2481 Undefined weak syms won't yet be marked as dynamic. */
2482 if (h
->dynindx
== -1
2483 && ! h
->forced_local
2484 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2487 /* If that succeeded, we know we'll be keeping all the
2489 if (h
->dynindx
!= -1)
2493 eh
->dyn_relocs
= NULL
;
2498 /* Finally, allocate space. */
2499 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2503 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2505 BFD_ASSERT (sreloc
!= NULL
);
2507 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2513 /* Allocate space in .plt, .got and associated reloc sections for
2514 local dynamic relocs. */
2517 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2519 struct elf_link_hash_entry
*h
2520 = (struct elf_link_hash_entry
*) *slot
;
2522 if (h
->type
!= STT_GNU_IFUNC
2526 || h
->root
.type
!= bfd_link_hash_defined
)
2529 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2532 /* Find any dynamic relocs that apply to read-only sections. */
2535 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2538 struct elf_x86_64_link_hash_entry
*eh
;
2539 struct elf_dyn_relocs
*p
;
2541 /* Skip local IFUNC symbols. */
2542 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2545 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2546 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2548 asection
*s
= p
->sec
->output_section
;
2550 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2552 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2554 info
->flags
|= DF_TEXTREL
;
2556 if (info
->warn_shared_textrel
&& info
->shared
)
2557 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2558 p
->sec
->owner
, h
->root
.root
.string
,
2561 /* Not an error, just cut short the traversal. */
2569 mov foo@GOTPCREL(%rip), %reg
2572 with the local symbol, foo. */
2575 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2576 struct bfd_link_info
*link_info
)
2578 Elf_Internal_Shdr
*symtab_hdr
;
2579 Elf_Internal_Rela
*internal_relocs
;
2580 Elf_Internal_Rela
*irel
, *irelend
;
2582 struct elf_x86_64_link_hash_table
*htab
;
2583 bfd_boolean changed_contents
;
2584 bfd_boolean changed_relocs
;
2585 bfd_signed_vma
*local_got_refcounts
;
2587 /* Don't even try to convert non-ELF outputs. */
2588 if (!is_elf_hash_table (link_info
->hash
))
2591 /* Nothing to do if there are no codes, no relocations or no output. */
2592 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2593 || sec
->reloc_count
== 0
2594 || discarded_section (sec
))
2597 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2599 /* Load the relocations for this section. */
2600 internal_relocs
= (_bfd_elf_link_read_relocs
2601 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2602 link_info
->keep_memory
));
2603 if (internal_relocs
== NULL
)
2606 htab
= elf_x86_64_hash_table (link_info
);
2607 changed_contents
= FALSE
;
2608 changed_relocs
= FALSE
;
2609 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2611 /* Get the section contents. */
2612 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2613 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2616 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2620 irelend
= internal_relocs
+ sec
->reloc_count
;
2621 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2623 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2624 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2626 struct elf_link_hash_entry
*h
;
2628 if (r_type
!= R_X86_64_GOTPCREL
)
2631 /* Get the symbol referred to by the reloc. */
2632 if (r_symndx
< symtab_hdr
->sh_info
)
2634 Elf_Internal_Sym
*isym
;
2636 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2639 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2640 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2641 && bfd_get_8 (input_bfd
,
2642 contents
+ irel
->r_offset
- 2) == 0x8b)
2644 bfd_put_8 (output_bfd
, 0x8d,
2645 contents
+ irel
->r_offset
- 2);
2646 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2647 if (local_got_refcounts
!= NULL
2648 && local_got_refcounts
[r_symndx
] > 0)
2649 local_got_refcounts
[r_symndx
] -= 1;
2650 changed_contents
= TRUE
;
2651 changed_relocs
= TRUE
;
2656 indx
= r_symndx
- symtab_hdr
->sh_info
;
2657 h
= elf_sym_hashes (abfd
)[indx
];
2658 BFD_ASSERT (h
!= NULL
);
2660 while (h
->root
.type
== bfd_link_hash_indirect
2661 || h
->root
.type
== bfd_link_hash_warning
)
2662 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2664 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2665 avoid optimizing _DYNAMIC since ld.so may use its link-time
2668 && h
->type
!= STT_GNU_IFUNC
2669 && h
!= htab
->elf
.hdynamic
2670 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2671 && bfd_get_8 (input_bfd
,
2672 contents
+ irel
->r_offset
- 2) == 0x8b)
2674 bfd_put_8 (output_bfd
, 0x8d,
2675 contents
+ irel
->r_offset
- 2);
2676 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2677 if (h
->got
.refcount
> 0)
2678 h
->got
.refcount
-= 1;
2679 changed_contents
= TRUE
;
2680 changed_relocs
= TRUE
;
2684 if (contents
!= NULL
2685 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2687 if (!changed_contents
&& !link_info
->keep_memory
)
2691 /* Cache the section contents for elf_link_input_bfd. */
2692 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2696 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2698 if (!changed_relocs
)
2699 free (internal_relocs
);
2701 elf_section_data (sec
)->relocs
= internal_relocs
;
2707 if (contents
!= NULL
2708 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2710 if (internal_relocs
!= NULL
2711 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2712 free (internal_relocs
);
2716 /* Set the sizes of the dynamic sections. */
2719 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2720 struct bfd_link_info
*info
)
2722 struct elf_x86_64_link_hash_table
*htab
;
2727 const struct elf_backend_data
*bed
;
2729 htab
= elf_x86_64_hash_table (info
);
2732 bed
= get_elf_backend_data (output_bfd
);
2734 dynobj
= htab
->elf
.dynobj
;
2738 if (htab
->elf
.dynamic_sections_created
)
2740 /* Set the contents of the .interp section to the interpreter. */
2741 if (info
->executable
)
2743 s
= bfd_get_linker_section (dynobj
, ".interp");
2746 s
->size
= htab
->dynamic_interpreter_size
;
2747 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2751 /* Set up .got offsets for local syms, and space for local dynamic
2753 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2755 bfd_signed_vma
*local_got
;
2756 bfd_signed_vma
*end_local_got
;
2757 char *local_tls_type
;
2758 bfd_vma
*local_tlsdesc_gotent
;
2759 bfd_size_type locsymcount
;
2760 Elf_Internal_Shdr
*symtab_hdr
;
2763 if (! is_x86_64_elf (ibfd
))
2766 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2768 struct elf_dyn_relocs
*p
;
2770 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2773 for (p
= (struct elf_dyn_relocs
*)
2774 (elf_section_data (s
)->local_dynrel
);
2778 if (!bfd_is_abs_section (p
->sec
)
2779 && bfd_is_abs_section (p
->sec
->output_section
))
2781 /* Input section has been discarded, either because
2782 it is a copy of a linkonce section or due to
2783 linker script /DISCARD/, so we'll be discarding
2786 else if (p
->count
!= 0)
2788 srel
= elf_section_data (p
->sec
)->sreloc
;
2789 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2790 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2791 && (info
->flags
& DF_TEXTREL
) == 0)
2793 info
->flags
|= DF_TEXTREL
;
2794 if (info
->warn_shared_textrel
&& info
->shared
)
2795 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2796 p
->sec
->owner
, p
->sec
);
2802 local_got
= elf_local_got_refcounts (ibfd
);
2806 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2807 locsymcount
= symtab_hdr
->sh_info
;
2808 end_local_got
= local_got
+ locsymcount
;
2809 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2810 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2812 srel
= htab
->elf
.srelgot
;
2813 for (; local_got
< end_local_got
;
2814 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2816 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2819 if (GOT_TLS_GDESC_P (*local_tls_type
))
2821 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2822 - elf_x86_64_compute_jump_table_size (htab
);
2823 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2824 *local_got
= (bfd_vma
) -2;
2826 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2827 || GOT_TLS_GD_P (*local_tls_type
))
2829 *local_got
= s
->size
;
2830 s
->size
+= GOT_ENTRY_SIZE
;
2831 if (GOT_TLS_GD_P (*local_tls_type
))
2832 s
->size
+= GOT_ENTRY_SIZE
;
2835 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2836 || *local_tls_type
== GOT_TLS_IE
)
2838 if (GOT_TLS_GDESC_P (*local_tls_type
))
2840 htab
->elf
.srelplt
->size
2841 += bed
->s
->sizeof_rela
;
2842 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2844 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2845 || GOT_TLS_GD_P (*local_tls_type
))
2846 srel
->size
+= bed
->s
->sizeof_rela
;
2850 *local_got
= (bfd_vma
) -1;
2854 if (htab
->tls_ld_got
.refcount
> 0)
2856 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2858 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2859 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2860 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2863 htab
->tls_ld_got
.offset
= -1;
2865 /* Allocate global sym .plt and .got entries, and space for global
2866 sym dynamic relocs. */
2867 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2870 /* Allocate .plt and .got entries, and space for local symbols. */
2871 htab_traverse (htab
->loc_hash_table
,
2872 elf_x86_64_allocate_local_dynrelocs
,
2875 /* For every jump slot reserved in the sgotplt, reloc_count is
2876 incremented. However, when we reserve space for TLS descriptors,
2877 it's not incremented, so in order to compute the space reserved
2878 for them, it suffices to multiply the reloc count by the jump
2881 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2882 so that R_X86_64_IRELATIVE entries come last. */
2883 if (htab
->elf
.srelplt
)
2885 htab
->sgotplt_jump_table_size
2886 = elf_x86_64_compute_jump_table_size (htab
);
2887 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
2889 else if (htab
->elf
.irelplt
)
2890 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
2892 if (htab
->tlsdesc_plt
)
2894 /* If we're not using lazy TLS relocations, don't generate the
2895 PLT and GOT entries they require. */
2896 if ((info
->flags
& DF_BIND_NOW
))
2897 htab
->tlsdesc_plt
= 0;
2900 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2901 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2902 /* Reserve room for the initial entry.
2903 FIXME: we could probably do away with it in this case. */
2904 if (htab
->elf
.splt
->size
== 0)
2905 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2906 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2907 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2911 if (htab
->elf
.sgotplt
)
2913 /* Don't allocate .got.plt section if there are no GOT nor PLT
2914 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2915 if ((htab
->elf
.hgot
== NULL
2916 || !htab
->elf
.hgot
->ref_regular_nonweak
)
2917 && (htab
->elf
.sgotplt
->size
2918 == get_elf_backend_data (output_bfd
)->got_header_size
)
2919 && (htab
->elf
.splt
== NULL
2920 || htab
->elf
.splt
->size
== 0)
2921 && (htab
->elf
.sgot
== NULL
2922 || htab
->elf
.sgot
->size
== 0)
2923 && (htab
->elf
.iplt
== NULL
2924 || htab
->elf
.iplt
->size
== 0)
2925 && (htab
->elf
.igotplt
== NULL
2926 || htab
->elf
.igotplt
->size
== 0))
2927 htab
->elf
.sgotplt
->size
= 0;
2930 if (htab
->plt_eh_frame
!= NULL
2931 && htab
->elf
.splt
!= NULL
2932 && htab
->elf
.splt
->size
!= 0
2933 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
2934 && _bfd_elf_eh_frame_present (info
))
2936 const struct elf_x86_64_backend_data
*arch_data
2937 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
2938 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
2941 /* We now have determined the sizes of the various dynamic sections.
2942 Allocate memory for them. */
2944 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2946 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2949 if (s
== htab
->elf
.splt
2950 || s
== htab
->elf
.sgot
2951 || s
== htab
->elf
.sgotplt
2952 || s
== htab
->elf
.iplt
2953 || s
== htab
->elf
.igotplt
2954 || s
== htab
->plt_eh_frame
2955 || s
== htab
->sdynbss
)
2957 /* Strip this section if we don't need it; see the
2960 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2962 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2965 /* We use the reloc_count field as a counter if we need
2966 to copy relocs into the output file. */
2967 if (s
!= htab
->elf
.srelplt
)
2972 /* It's not one of our sections, so don't allocate space. */
2978 /* If we don't need this section, strip it from the
2979 output file. This is mostly to handle .rela.bss and
2980 .rela.plt. We must create both sections in
2981 create_dynamic_sections, because they must be created
2982 before the linker maps input sections to output
2983 sections. The linker does that before
2984 adjust_dynamic_symbol is called, and it is that
2985 function which decides whether anything needs to go
2986 into these sections. */
2988 s
->flags
|= SEC_EXCLUDE
;
2992 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2995 /* Allocate memory for the section contents. We use bfd_zalloc
2996 here in case unused entries are not reclaimed before the
2997 section's contents are written out. This should not happen,
2998 but this way if it does, we get a R_X86_64_NONE reloc instead
3000 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3001 if (s
->contents
== NULL
)
3005 if (htab
->plt_eh_frame
!= NULL
3006 && htab
->plt_eh_frame
->contents
!= NULL
)
3008 const struct elf_x86_64_backend_data
*arch_data
3009 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
3011 memcpy (htab
->plt_eh_frame
->contents
,
3012 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3013 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3014 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3017 if (htab
->elf
.dynamic_sections_created
)
3019 /* Add some entries to the .dynamic section. We fill in the
3020 values later, in elf_x86_64_finish_dynamic_sections, but we
3021 must add the entries now so that we get the correct size for
3022 the .dynamic section. The DT_DEBUG entry is filled in by the
3023 dynamic linker and used by the debugger. */
3024 #define add_dynamic_entry(TAG, VAL) \
3025 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3027 if (info
->executable
)
3029 if (!add_dynamic_entry (DT_DEBUG
, 0))
3033 if (htab
->elf
.splt
->size
!= 0)
3035 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3036 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3037 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3038 || !add_dynamic_entry (DT_JMPREL
, 0))
3041 if (htab
->tlsdesc_plt
3042 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3043 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3049 if (!add_dynamic_entry (DT_RELA
, 0)
3050 || !add_dynamic_entry (DT_RELASZ
, 0)
3051 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3054 /* If any dynamic relocs apply to a read-only section,
3055 then we need a DT_TEXTREL entry. */
3056 if ((info
->flags
& DF_TEXTREL
) == 0)
3057 elf_link_hash_traverse (&htab
->elf
,
3058 elf_x86_64_readonly_dynrelocs
,
3061 if ((info
->flags
& DF_TEXTREL
) != 0)
3063 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3068 #undef add_dynamic_entry
3074 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3075 struct bfd_link_info
*info
)
3077 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3081 struct elf_link_hash_entry
*tlsbase
;
3083 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3084 "_TLS_MODULE_BASE_",
3085 FALSE
, FALSE
, FALSE
);
3087 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3089 struct elf_x86_64_link_hash_table
*htab
;
3090 struct bfd_link_hash_entry
*bh
= NULL
;
3091 const struct elf_backend_data
*bed
3092 = get_elf_backend_data (output_bfd
);
3094 htab
= elf_x86_64_hash_table (info
);
3098 if (!(_bfd_generic_link_add_one_symbol
3099 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3100 tls_sec
, 0, NULL
, FALSE
,
3101 bed
->collect
, &bh
)))
3104 htab
->tls_module_base
= bh
;
3106 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3107 tlsbase
->def_regular
= 1;
3108 tlsbase
->other
= STV_HIDDEN
;
3109 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3116 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3117 executables. Rather than setting it to the beginning of the TLS
3118 section, we have to set it to the end. This function may be called
3119 multiple times, it is idempotent. */
3122 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3124 struct elf_x86_64_link_hash_table
*htab
;
3125 struct bfd_link_hash_entry
*base
;
3127 if (!info
->executable
)
3130 htab
= elf_x86_64_hash_table (info
);
3134 base
= htab
->tls_module_base
;
3138 base
->u
.def
.value
= htab
->elf
.tls_size
;
3141 /* Return the base VMA address which should be subtracted from real addresses
3142 when resolving @dtpoff relocation.
3143 This is PT_TLS segment p_vaddr. */
3146 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3148 /* If tls_sec is NULL, we should have signalled an error already. */
3149 if (elf_hash_table (info
)->tls_sec
== NULL
)
3151 return elf_hash_table (info
)->tls_sec
->vma
;
3154 /* Return the relocation value for @tpoff relocation
3155 if STT_TLS virtual address is ADDRESS. */
3158 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3160 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3161 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3162 bfd_vma static_tls_size
;
3164 /* If tls_segment is NULL, we should have signalled an error already. */
3165 if (htab
->tls_sec
== NULL
)
3168 /* Consider special static TLS alignment requirements. */
3169 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3170 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3173 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3177 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3179 /* Opcode Instruction
3182 0x0f 0x8x conditional jump */
3184 && (contents
[offset
- 1] == 0xe8
3185 || contents
[offset
- 1] == 0xe9))
3187 && contents
[offset
- 2] == 0x0f
3188 && (contents
[offset
- 1] & 0xf0) == 0x80));
3191 /* Relocate an x86_64 ELF section. */
3194 elf_x86_64_relocate_section (bfd
*output_bfd
,
3195 struct bfd_link_info
*info
,
3197 asection
*input_section
,
3199 Elf_Internal_Rela
*relocs
,
3200 Elf_Internal_Sym
*local_syms
,
3201 asection
**local_sections
)
3203 struct elf_x86_64_link_hash_table
*htab
;
3204 Elf_Internal_Shdr
*symtab_hdr
;
3205 struct elf_link_hash_entry
**sym_hashes
;
3206 bfd_vma
*local_got_offsets
;
3207 bfd_vma
*local_tlsdesc_gotents
;
3208 Elf_Internal_Rela
*rel
;
3209 Elf_Internal_Rela
*relend
;
3210 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3212 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3214 htab
= elf_x86_64_hash_table (info
);
3217 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3218 sym_hashes
= elf_sym_hashes (input_bfd
);
3219 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3220 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3222 elf_x86_64_set_tls_module_base (info
);
3225 relend
= relocs
+ input_section
->reloc_count
;
3226 for (; rel
< relend
; rel
++)
3228 unsigned int r_type
;
3229 reloc_howto_type
*howto
;
3230 unsigned long r_symndx
;
3231 struct elf_link_hash_entry
*h
;
3232 Elf_Internal_Sym
*sym
;
3234 bfd_vma off
, offplt
;
3236 bfd_boolean unresolved_reloc
;
3237 bfd_reloc_status_type r
;
3242 r_type
= ELF32_R_TYPE (rel
->r_info
);
3243 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3244 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3247 if (r_type
>= (int) R_X86_64_standard
)
3249 (*_bfd_error_handler
)
3250 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3251 input_bfd
, input_section
, r_type
);
3252 bfd_set_error (bfd_error_bad_value
);
3256 if (r_type
!= (int) R_X86_64_32
3257 || ABI_64_P (output_bfd
))
3258 howto
= x86_64_elf_howto_table
+ r_type
;
3260 howto
= (x86_64_elf_howto_table
3261 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3262 r_symndx
= htab
->r_sym (rel
->r_info
);
3266 unresolved_reloc
= FALSE
;
3267 if (r_symndx
< symtab_hdr
->sh_info
)
3269 sym
= local_syms
+ r_symndx
;
3270 sec
= local_sections
[r_symndx
];
3272 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3274 st_size
= sym
->st_size
;
3276 /* Relocate against local STT_GNU_IFUNC symbol. */
3277 if (!info
->relocatable
3278 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3280 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3285 /* Set STT_GNU_IFUNC symbol value. */
3286 h
->root
.u
.def
.value
= sym
->st_value
;
3287 h
->root
.u
.def
.section
= sec
;
3292 bfd_boolean warned ATTRIBUTE_UNUSED
;
3294 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3295 r_symndx
, symtab_hdr
, sym_hashes
,
3297 unresolved_reloc
, warned
);
3301 if (sec
!= NULL
&& discarded_section (sec
))
3302 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3303 rel
, 1, relend
, howto
, 0, contents
);
3305 if (info
->relocatable
)
3308 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3310 if (r_type
== R_X86_64_64
)
3312 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3313 zero-extend it to 64bit if addend is zero. */
3314 r_type
= R_X86_64_32
;
3315 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3317 else if (r_type
== R_X86_64_SIZE64
)
3319 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3320 zero-extend it to 64bit if addend is zero. */
3321 r_type
= R_X86_64_SIZE32
;
3322 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3326 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3327 it here if it is defined in a non-shared object. */
3329 && h
->type
== STT_GNU_IFUNC
3336 if ((input_section
->flags
& SEC_ALLOC
) == 0
3337 || h
->plt
.offset
== (bfd_vma
) -1)
3340 /* STT_GNU_IFUNC symbol must go through PLT. */
3341 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3342 relocation
= (plt
->output_section
->vma
3343 + plt
->output_offset
+ h
->plt
.offset
);
3348 if (h
->root
.root
.string
)
3349 name
= h
->root
.root
.string
;
3351 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3353 (*_bfd_error_handler
)
3354 (_("%B: relocation %s against STT_GNU_IFUNC "
3355 "symbol `%s' isn't handled by %s"), input_bfd
,
3356 x86_64_elf_howto_table
[r_type
].name
,
3357 name
, __FUNCTION__
);
3358 bfd_set_error (bfd_error_bad_value
);
3367 if (ABI_64_P (output_bfd
))
3371 if (rel
->r_addend
!= 0)
3373 if (h
->root
.root
.string
)
3374 name
= h
->root
.root
.string
;
3376 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3378 (*_bfd_error_handler
)
3379 (_("%B: relocation %s against STT_GNU_IFUNC "
3380 "symbol `%s' has non-zero addend: %d"),
3381 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3382 name
, rel
->r_addend
);
3383 bfd_set_error (bfd_error_bad_value
);
3387 /* Generate dynamic relcoation only when there is a
3388 non-GOT reference in a shared object. */
3389 if (info
->shared
&& h
->non_got_ref
)
3391 Elf_Internal_Rela outrel
;
3394 /* Need a dynamic relocation to get the real function
3396 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3400 if (outrel
.r_offset
== (bfd_vma
) -1
3401 || outrel
.r_offset
== (bfd_vma
) -2)
3404 outrel
.r_offset
+= (input_section
->output_section
->vma
3405 + input_section
->output_offset
);
3407 if (h
->dynindx
== -1
3409 || info
->executable
)
3411 /* This symbol is resolved locally. */
3412 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3413 outrel
.r_addend
= (h
->root
.u
.def
.value
3414 + h
->root
.u
.def
.section
->output_section
->vma
3415 + h
->root
.u
.def
.section
->output_offset
);
3419 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3420 outrel
.r_addend
= 0;
3423 sreloc
= htab
->elf
.irelifunc
;
3424 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3426 /* If this reloc is against an external symbol, we
3427 do not want to fiddle with the addend. Otherwise,
3428 we need to include the symbol value so that it
3429 becomes an addend for the dynamic reloc. For an
3430 internal symbol, we have updated addend. */
3436 case R_X86_64_PLT32
:
3439 case R_X86_64_GOTPCREL
:
3440 case R_X86_64_GOTPCREL64
:
3441 base_got
= htab
->elf
.sgot
;
3442 off
= h
->got
.offset
;
3444 if (base_got
== NULL
)
3447 if (off
== (bfd_vma
) -1)
3449 /* We can't use h->got.offset here to save state, or
3450 even just remember the offset, as finish_dynamic_symbol
3451 would use that as offset into .got. */
3453 if (htab
->elf
.splt
!= NULL
)
3455 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3456 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3457 base_got
= htab
->elf
.sgotplt
;
3461 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3462 off
= plt_index
* GOT_ENTRY_SIZE
;
3463 base_got
= htab
->elf
.igotplt
;
3466 if (h
->dynindx
== -1
3470 /* This references the local defitionion. We must
3471 initialize this entry in the global offset table.
3472 Since the offset must always be a multiple of 8,
3473 we use the least significant bit to record
3474 whether we have initialized it already.
3476 When doing a dynamic link, we create a .rela.got
3477 relocation entry to initialize the value. This
3478 is done in the finish_dynamic_symbol routine. */
3483 bfd_put_64 (output_bfd
, relocation
,
3484 base_got
->contents
+ off
);
3485 /* Note that this is harmless for the GOTPLT64
3486 case, as -1 | 1 still is -1. */
3492 relocation
= (base_got
->output_section
->vma
3493 + base_got
->output_offset
+ off
);
3499 /* When generating a shared object, the relocations handled here are
3500 copied into the output file to be resolved at run time. */
3503 case R_X86_64_GOT32
:
3504 case R_X86_64_GOT64
:
3505 /* Relocation is to the entry for this symbol in the global
3507 case R_X86_64_GOTPCREL
:
3508 case R_X86_64_GOTPCREL64
:
3509 /* Use global offset table entry as symbol value. */
3510 case R_X86_64_GOTPLT64
:
3511 /* This is the same as GOT64 for relocation purposes, but
3512 indicates the existence of a PLT entry. The difficulty is,
3513 that we must calculate the GOT slot offset from the PLT
3514 offset, if this symbol got a PLT entry (it was global).
3515 Additionally if it's computed from the PLT entry, then that
3516 GOT offset is relative to .got.plt, not to .got. */
3517 base_got
= htab
->elf
.sgot
;
3519 if (htab
->elf
.sgot
== NULL
)
3526 off
= h
->got
.offset
;
3528 && h
->plt
.offset
!= (bfd_vma
)-1
3529 && off
== (bfd_vma
)-1)
3531 /* We can't use h->got.offset here to save
3532 state, or even just remember the offset, as
3533 finish_dynamic_symbol would use that as offset into
3535 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3536 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3537 base_got
= htab
->elf
.sgotplt
;
3540 dyn
= htab
->elf
.dynamic_sections_created
;
3542 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3544 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3545 || (ELF_ST_VISIBILITY (h
->other
)
3546 && h
->root
.type
== bfd_link_hash_undefweak
))
3548 /* This is actually a static link, or it is a -Bsymbolic
3549 link and the symbol is defined locally, or the symbol
3550 was forced to be local because of a version file. We
3551 must initialize this entry in the global offset table.
3552 Since the offset must always be a multiple of 8, we
3553 use the least significant bit to record whether we
3554 have initialized it already.
3556 When doing a dynamic link, we create a .rela.got
3557 relocation entry to initialize the value. This is
3558 done in the finish_dynamic_symbol routine. */
3563 bfd_put_64 (output_bfd
, relocation
,
3564 base_got
->contents
+ off
);
3565 /* Note that this is harmless for the GOTPLT64 case,
3566 as -1 | 1 still is -1. */
3571 unresolved_reloc
= FALSE
;
3575 if (local_got_offsets
== NULL
)
3578 off
= local_got_offsets
[r_symndx
];
3580 /* The offset must always be a multiple of 8. We use
3581 the least significant bit to record whether we have
3582 already generated the necessary reloc. */
3587 bfd_put_64 (output_bfd
, relocation
,
3588 base_got
->contents
+ off
);
3593 Elf_Internal_Rela outrel
;
3595 /* We need to generate a R_X86_64_RELATIVE reloc
3596 for the dynamic linker. */
3597 s
= htab
->elf
.srelgot
;
3601 outrel
.r_offset
= (base_got
->output_section
->vma
3602 + base_got
->output_offset
3604 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3605 outrel
.r_addend
= relocation
;
3606 elf_append_rela (output_bfd
, s
, &outrel
);
3609 local_got_offsets
[r_symndx
] |= 1;
3613 if (off
>= (bfd_vma
) -2)
3616 relocation
= base_got
->output_section
->vma
3617 + base_got
->output_offset
+ off
;
3618 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3619 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3620 - htab
->elf
.sgotplt
->output_offset
;
3624 case R_X86_64_GOTOFF64
:
3625 /* Relocation is relative to the start of the global offset
3628 /* Check to make sure it isn't a protected function symbol
3629 for shared library since it may not be local when used
3630 as function address. */
3631 if (!info
->executable
3633 && !SYMBOLIC_BIND (info
, h
)
3635 && h
->type
== STT_FUNC
3636 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3638 (*_bfd_error_handler
)
3639 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3640 input_bfd
, h
->root
.root
.string
);
3641 bfd_set_error (bfd_error_bad_value
);
3645 /* Note that sgot is not involved in this
3646 calculation. We always want the start of .got.plt. If we
3647 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3648 permitted by the ABI, we might have to change this
3650 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3651 + htab
->elf
.sgotplt
->output_offset
;
3654 case R_X86_64_GOTPC32
:
3655 case R_X86_64_GOTPC64
:
3656 /* Use global offset table as symbol value. */
3657 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3658 + htab
->elf
.sgotplt
->output_offset
;
3659 unresolved_reloc
= FALSE
;
3662 case R_X86_64_PLTOFF64
:
3663 /* Relocation is PLT entry relative to GOT. For local
3664 symbols it's the symbol itself relative to GOT. */
3666 /* See PLT32 handling. */
3667 && h
->plt
.offset
!= (bfd_vma
) -1
3668 && htab
->elf
.splt
!= NULL
)
3670 relocation
= (htab
->elf
.splt
->output_section
->vma
3671 + htab
->elf
.splt
->output_offset
3673 unresolved_reloc
= FALSE
;
3676 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3677 + htab
->elf
.sgotplt
->output_offset
;
3680 case R_X86_64_PLT32
:
3681 /* Relocation is to the entry for this symbol in the
3682 procedure linkage table. */
3684 /* Resolve a PLT32 reloc against a local symbol directly,
3685 without using the procedure linkage table. */
3689 if (h
->plt
.offset
== (bfd_vma
) -1
3690 || htab
->elf
.splt
== NULL
)
3692 /* We didn't make a PLT entry for this symbol. This
3693 happens when statically linking PIC code, or when
3694 using -Bsymbolic. */
3698 relocation
= (htab
->elf
.splt
->output_section
->vma
3699 + htab
->elf
.splt
->output_offset
3701 unresolved_reloc
= FALSE
;
3704 case R_X86_64_SIZE32
:
3705 case R_X86_64_SIZE64
:
3706 /* Set to symbol size. */
3707 relocation
= st_size
;
3708 if (h
&& h
->type
== STT_TLS
&& st_size
!= 0)
3710 /* Resolve size relocation against non-zero TLS symbol. */
3711 unresolved_reloc
= FALSE
;
3720 && (input_section
->flags
& SEC_ALLOC
) != 0
3721 && (input_section
->flags
& SEC_READONLY
) != 0
3724 bfd_boolean fail
= FALSE
;
3726 = (r_type
== R_X86_64_PC32
3727 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3729 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3731 /* Symbol is referenced locally. Make sure it is
3732 defined locally or for a branch. */
3733 fail
= !h
->def_regular
&& !branch
;
3737 /* Symbol isn't referenced locally. We only allow
3738 branch to symbol with non-default visibility. */
3740 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3747 const char *pic
= "";
3749 switch (ELF_ST_VISIBILITY (h
->other
))
3752 v
= _("hidden symbol");
3755 v
= _("internal symbol");
3758 v
= _("protected symbol");
3762 pic
= _("; recompile with -fPIC");
3767 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3769 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3771 (*_bfd_error_handler
) (fmt
, input_bfd
,
3772 x86_64_elf_howto_table
[r_type
].name
,
3773 v
, h
->root
.root
.string
, pic
);
3774 bfd_set_error (bfd_error_bad_value
);
3785 /* FIXME: The ABI says the linker should make sure the value is
3786 the same when it's zeroextended to 64 bit. */
3789 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3794 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3795 || h
->root
.type
!= bfd_link_hash_undefweak
)
3796 && ((! IS_X86_64_PCREL_TYPE (r_type
)
3797 && r_type
!= R_X86_64_SIZE32
3798 && r_type
!= R_X86_64_SIZE64
)
3799 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3800 || (ELIMINATE_COPY_RELOCS
3807 || h
->root
.type
== bfd_link_hash_undefweak
3808 || h
->root
.type
== bfd_link_hash_undefined
)))
3810 Elf_Internal_Rela outrel
;
3811 bfd_boolean skip
, relocate
;
3814 /* When generating a shared object, these relocations
3815 are copied into the output file to be resolved at run
3821 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3823 if (outrel
.r_offset
== (bfd_vma
) -1)
3825 else if (outrel
.r_offset
== (bfd_vma
) -2)
3826 skip
= TRUE
, relocate
= TRUE
;
3828 outrel
.r_offset
+= (input_section
->output_section
->vma
3829 + input_section
->output_offset
);
3832 memset (&outrel
, 0, sizeof outrel
);
3834 /* h->dynindx may be -1 if this symbol was marked to
3838 && (IS_X86_64_PCREL_TYPE (r_type
)
3840 || ! SYMBOLIC_BIND (info
, h
)
3841 || ! h
->def_regular
))
3843 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3844 outrel
.r_addend
= rel
->r_addend
;
3848 /* This symbol is local, or marked to become local. */
3849 if (r_type
== htab
->pointer_r_type
)
3852 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3853 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3855 else if (r_type
== R_X86_64_64
3856 && !ABI_64_P (output_bfd
))
3859 outrel
.r_info
= htab
->r_info (0,
3860 R_X86_64_RELATIVE64
);
3861 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3862 /* Check addend overflow. */
3863 if ((outrel
.r_addend
& 0x80000000)
3864 != (rel
->r_addend
& 0x80000000))
3867 int addend
= rel
->r_addend
;
3868 if (h
&& h
->root
.root
.string
)
3869 name
= h
->root
.root
.string
;
3871 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3874 (*_bfd_error_handler
)
3875 (_("%B: addend -0x%x in relocation %s against "
3876 "symbol `%s' at 0x%lx in section `%A' is "
3878 input_bfd
, input_section
, addend
,
3879 x86_64_elf_howto_table
[r_type
].name
,
3880 name
, (unsigned long) rel
->r_offset
);
3882 (*_bfd_error_handler
)
3883 (_("%B: addend 0x%x in relocation %s against "
3884 "symbol `%s' at 0x%lx in section `%A' is "
3886 input_bfd
, input_section
, addend
,
3887 x86_64_elf_howto_table
[r_type
].name
,
3888 name
, (unsigned long) rel
->r_offset
);
3889 bfd_set_error (bfd_error_bad_value
);
3897 if (bfd_is_abs_section (sec
))
3899 else if (sec
== NULL
|| sec
->owner
== NULL
)
3901 bfd_set_error (bfd_error_bad_value
);
3908 /* We are turning this relocation into one
3909 against a section symbol. It would be
3910 proper to subtract the symbol's value,
3911 osec->vma, from the emitted reloc addend,
3912 but ld.so expects buggy relocs. */
3913 osec
= sec
->output_section
;
3914 sindx
= elf_section_data (osec
)->dynindx
;
3917 asection
*oi
= htab
->elf
.text_index_section
;
3918 sindx
= elf_section_data (oi
)->dynindx
;
3920 BFD_ASSERT (sindx
!= 0);
3923 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3924 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3928 sreloc
= elf_section_data (input_section
)->sreloc
;
3930 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3932 r
= bfd_reloc_notsupported
;
3933 goto check_relocation_error
;
3936 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3938 /* If this reloc is against an external symbol, we do
3939 not want to fiddle with the addend. Otherwise, we
3940 need to include the symbol value so that it becomes
3941 an addend for the dynamic reloc. */
3948 case R_X86_64_TLSGD
:
3949 case R_X86_64_GOTPC32_TLSDESC
:
3950 case R_X86_64_TLSDESC_CALL
:
3951 case R_X86_64_GOTTPOFF
:
3952 tls_type
= GOT_UNKNOWN
;
3953 if (h
== NULL
&& local_got_offsets
)
3954 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3956 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3958 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3959 input_section
, contents
,
3960 symtab_hdr
, sym_hashes
,
3961 &r_type
, tls_type
, rel
,
3962 relend
, h
, r_symndx
))
3965 if (r_type
== R_X86_64_TPOFF32
)
3967 bfd_vma roff
= rel
->r_offset
;
3969 BFD_ASSERT (! unresolved_reloc
);
3971 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3973 /* GD->LE transition. For 64bit, change
3974 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3975 .word 0x6666; rex64; call __tls_get_addr
3978 leaq foo@tpoff(%rax), %rax
3980 leaq foo@tlsgd(%rip), %rdi
3981 .word 0x6666; rex64; call __tls_get_addr
3984 leaq foo@tpoff(%rax), %rax */
3985 if (ABI_64_P (output_bfd
))
3986 memcpy (contents
+ roff
- 4,
3987 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3990 memcpy (contents
+ roff
- 3,
3991 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3993 bfd_put_32 (output_bfd
,
3994 elf_x86_64_tpoff (info
, relocation
),
3995 contents
+ roff
+ 8);
3996 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4000 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4002 /* GDesc -> LE transition.
4003 It's originally something like:
4004 leaq x@tlsdesc(%rip), %rax
4007 movl $x@tpoff, %rax. */
4009 unsigned int val
, type
;
4011 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4012 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4013 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4014 contents
+ roff
- 3);
4015 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4016 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4017 contents
+ roff
- 1);
4018 bfd_put_32 (output_bfd
,
4019 elf_x86_64_tpoff (info
, relocation
),
4023 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4025 /* GDesc -> LE transition.
4030 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4031 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4034 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4036 /* IE->LE transition:
4037 Originally it can be one of:
4038 movq foo@gottpoff(%rip), %reg
4039 addq foo@gottpoff(%rip), %reg
4042 leaq foo(%reg), %reg
4045 unsigned int val
, type
, reg
;
4047 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4048 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4049 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4055 bfd_put_8 (output_bfd
, 0x49,
4056 contents
+ roff
- 3);
4057 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4058 bfd_put_8 (output_bfd
, 0x41,
4059 contents
+ roff
- 3);
4060 bfd_put_8 (output_bfd
, 0xc7,
4061 contents
+ roff
- 2);
4062 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4063 contents
+ roff
- 1);
4067 /* addq -> addq - addressing with %rsp/%r12 is
4070 bfd_put_8 (output_bfd
, 0x49,
4071 contents
+ roff
- 3);
4072 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4073 bfd_put_8 (output_bfd
, 0x41,
4074 contents
+ roff
- 3);
4075 bfd_put_8 (output_bfd
, 0x81,
4076 contents
+ roff
- 2);
4077 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4078 contents
+ roff
- 1);
4084 bfd_put_8 (output_bfd
, 0x4d,
4085 contents
+ roff
- 3);
4086 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4087 bfd_put_8 (output_bfd
, 0x45,
4088 contents
+ roff
- 3);
4089 bfd_put_8 (output_bfd
, 0x8d,
4090 contents
+ roff
- 2);
4091 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4092 contents
+ roff
- 1);
4094 bfd_put_32 (output_bfd
,
4095 elf_x86_64_tpoff (info
, relocation
),
4103 if (htab
->elf
.sgot
== NULL
)
4108 off
= h
->got
.offset
;
4109 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4113 if (local_got_offsets
== NULL
)
4116 off
= local_got_offsets
[r_symndx
];
4117 offplt
= local_tlsdesc_gotents
[r_symndx
];
4124 Elf_Internal_Rela outrel
;
4128 if (htab
->elf
.srelgot
== NULL
)
4131 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4133 if (GOT_TLS_GDESC_P (tls_type
))
4135 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4136 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4137 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4138 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4139 + htab
->elf
.sgotplt
->output_offset
4141 + htab
->sgotplt_jump_table_size
);
4142 sreloc
= htab
->elf
.srelplt
;
4144 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4146 outrel
.r_addend
= 0;
4147 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4150 sreloc
= htab
->elf
.srelgot
;
4152 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4153 + htab
->elf
.sgot
->output_offset
+ off
);
4155 if (GOT_TLS_GD_P (tls_type
))
4156 dr_type
= R_X86_64_DTPMOD64
;
4157 else if (GOT_TLS_GDESC_P (tls_type
))
4160 dr_type
= R_X86_64_TPOFF64
;
4162 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4163 outrel
.r_addend
= 0;
4164 if ((dr_type
== R_X86_64_TPOFF64
4165 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4166 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4167 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4169 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4171 if (GOT_TLS_GD_P (tls_type
))
4175 BFD_ASSERT (! unresolved_reloc
);
4176 bfd_put_64 (output_bfd
,
4177 relocation
- elf_x86_64_dtpoff_base (info
),
4178 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4182 bfd_put_64 (output_bfd
, 0,
4183 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4184 outrel
.r_info
= htab
->r_info (indx
,
4186 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4187 elf_append_rela (output_bfd
, sreloc
,
4196 local_got_offsets
[r_symndx
] |= 1;
4199 if (off
>= (bfd_vma
) -2
4200 && ! GOT_TLS_GDESC_P (tls_type
))
4202 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4204 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4205 || r_type
== R_X86_64_TLSDESC_CALL
)
4206 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4207 + htab
->elf
.sgotplt
->output_offset
4208 + offplt
+ htab
->sgotplt_jump_table_size
;
4210 relocation
= htab
->elf
.sgot
->output_section
->vma
4211 + htab
->elf
.sgot
->output_offset
+ off
;
4212 unresolved_reloc
= FALSE
;
4216 bfd_vma roff
= rel
->r_offset
;
4218 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4220 /* GD->IE transition. For 64bit, change
4221 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4222 .word 0x6666; rex64; call __tls_get_addr@plt
4225 addq foo@gottpoff(%rip), %rax
4227 leaq foo@tlsgd(%rip), %rdi
4228 .word 0x6666; rex64; call __tls_get_addr@plt
4231 addq foo@gottpoff(%rip), %rax */
4232 if (ABI_64_P (output_bfd
))
4233 memcpy (contents
+ roff
- 4,
4234 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4237 memcpy (contents
+ roff
- 3,
4238 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4241 relocation
= (htab
->elf
.sgot
->output_section
->vma
4242 + htab
->elf
.sgot
->output_offset
+ off
4244 - input_section
->output_section
->vma
4245 - input_section
->output_offset
4247 bfd_put_32 (output_bfd
, relocation
,
4248 contents
+ roff
+ 8);
4249 /* Skip R_X86_64_PLT32. */
4253 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4255 /* GDesc -> IE transition.
4256 It's originally something like:
4257 leaq x@tlsdesc(%rip), %rax
4260 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4262 /* Now modify the instruction as appropriate. To
4263 turn a leaq into a movq in the form we use it, it
4264 suffices to change the second byte from 0x8d to
4266 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4268 bfd_put_32 (output_bfd
,
4269 htab
->elf
.sgot
->output_section
->vma
4270 + htab
->elf
.sgot
->output_offset
+ off
4272 - input_section
->output_section
->vma
4273 - input_section
->output_offset
4278 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4280 /* GDesc -> IE transition.
4287 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4288 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4296 case R_X86_64_TLSLD
:
4297 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4298 input_section
, contents
,
4299 symtab_hdr
, sym_hashes
,
4300 &r_type
, GOT_UNKNOWN
,
4301 rel
, relend
, h
, r_symndx
))
4304 if (r_type
!= R_X86_64_TLSLD
)
4306 /* LD->LE transition:
4307 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4308 For 64bit, we change it into:
4309 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4310 For 32bit, we change it into:
4311 nopl 0x0(%rax); movl %fs:0, %eax. */
4313 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4314 if (ABI_64_P (output_bfd
))
4315 memcpy (contents
+ rel
->r_offset
- 3,
4316 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4318 memcpy (contents
+ rel
->r_offset
- 3,
4319 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4320 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4325 if (htab
->elf
.sgot
== NULL
)
4328 off
= htab
->tls_ld_got
.offset
;
4333 Elf_Internal_Rela outrel
;
4335 if (htab
->elf
.srelgot
== NULL
)
4338 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4339 + htab
->elf
.sgot
->output_offset
+ off
);
4341 bfd_put_64 (output_bfd
, 0,
4342 htab
->elf
.sgot
->contents
+ off
);
4343 bfd_put_64 (output_bfd
, 0,
4344 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4345 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4346 outrel
.r_addend
= 0;
4347 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4349 htab
->tls_ld_got
.offset
|= 1;
4351 relocation
= htab
->elf
.sgot
->output_section
->vma
4352 + htab
->elf
.sgot
->output_offset
+ off
;
4353 unresolved_reloc
= FALSE
;
4356 case R_X86_64_DTPOFF32
:
4357 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4358 relocation
-= elf_x86_64_dtpoff_base (info
);
4360 relocation
= elf_x86_64_tpoff (info
, relocation
);
4363 case R_X86_64_TPOFF32
:
4364 case R_X86_64_TPOFF64
:
4365 BFD_ASSERT (info
->executable
);
4366 relocation
= elf_x86_64_tpoff (info
, relocation
);
4373 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4374 because such sections are not SEC_ALLOC and thus ld.so will
4375 not process them. */
4376 if (unresolved_reloc
4377 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4379 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4380 rel
->r_offset
) != (bfd_vma
) -1)
4382 (*_bfd_error_handler
)
4383 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4386 (long) rel
->r_offset
,
4388 h
->root
.root
.string
);
4393 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4394 contents
, rel
->r_offset
,
4395 relocation
, rel
->r_addend
);
4397 check_relocation_error
:
4398 if (r
!= bfd_reloc_ok
)
4403 name
= h
->root
.root
.string
;
4406 name
= bfd_elf_string_from_elf_section (input_bfd
,
4407 symtab_hdr
->sh_link
,
4412 name
= bfd_section_name (input_bfd
, sec
);
4415 if (r
== bfd_reloc_overflow
)
4417 if (! ((*info
->callbacks
->reloc_overflow
)
4418 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4419 (bfd_vma
) 0, input_bfd
, input_section
,
4425 (*_bfd_error_handler
)
4426 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4427 input_bfd
, input_section
,
4428 (long) rel
->r_offset
, name
, (int) r
);
4437 /* Finish up dynamic symbol handling. We set the contents of various
4438 dynamic sections here. */
4441 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4442 struct bfd_link_info
*info
,
4443 struct elf_link_hash_entry
*h
,
4444 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4446 struct elf_x86_64_link_hash_table
*htab
;
4447 const struct elf_x86_64_backend_data
*const abed
4448 = get_elf_x86_64_backend_data (output_bfd
);
4450 htab
= elf_x86_64_hash_table (info
);
4454 if (h
->plt
.offset
!= (bfd_vma
) -1)
4458 Elf_Internal_Rela rela
;
4460 asection
*plt
, *gotplt
, *relplt
;
4461 const struct elf_backend_data
*bed
;
4463 /* When building a static executable, use .iplt, .igot.plt and
4464 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4465 if (htab
->elf
.splt
!= NULL
)
4467 plt
= htab
->elf
.splt
;
4468 gotplt
= htab
->elf
.sgotplt
;
4469 relplt
= htab
->elf
.srelplt
;
4473 plt
= htab
->elf
.iplt
;
4474 gotplt
= htab
->elf
.igotplt
;
4475 relplt
= htab
->elf
.irelplt
;
4478 /* This symbol has an entry in the procedure linkage table. Set
4480 if ((h
->dynindx
== -1
4481 && !((h
->forced_local
|| info
->executable
)
4483 && h
->type
== STT_GNU_IFUNC
))
4489 /* Get the index in the procedure linkage table which
4490 corresponds to this symbol. This is the index of this symbol
4491 in all the symbols for which we are making plt entries. The
4492 first entry in the procedure linkage table is reserved.
4494 Get the offset into the .got table of the entry that
4495 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4496 bytes. The first three are reserved for the dynamic linker.
4498 For static executables, we don't reserve anything. */
4500 if (plt
== htab
->elf
.splt
)
4502 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4503 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4507 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4508 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4511 /* Fill in the entry in the procedure linkage table. */
4512 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4513 abed
->plt_entry_size
);
4515 /* Insert the relocation positions of the plt section. */
4517 /* Put offset the PC-relative instruction referring to the GOT entry,
4518 subtracting the size of that instruction. */
4519 bfd_put_32 (output_bfd
,
4520 (gotplt
->output_section
->vma
4521 + gotplt
->output_offset
4523 - plt
->output_section
->vma
4524 - plt
->output_offset
4526 - abed
->plt_got_insn_size
),
4527 plt
->contents
+ h
->plt
.offset
+ abed
->plt_got_offset
);
4529 /* Fill in the entry in the global offset table, initially this
4530 points to the second part of the PLT entry. */
4531 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4532 + plt
->output_offset
4533 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4534 gotplt
->contents
+ got_offset
);
4536 /* Fill in the entry in the .rela.plt section. */
4537 rela
.r_offset
= (gotplt
->output_section
->vma
4538 + gotplt
->output_offset
4540 if (h
->dynindx
== -1
4541 || ((info
->executable
4542 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4544 && h
->type
== STT_GNU_IFUNC
))
4546 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4547 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4548 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4549 rela
.r_addend
= (h
->root
.u
.def
.value
4550 + h
->root
.u
.def
.section
->output_section
->vma
4551 + h
->root
.u
.def
.section
->output_offset
);
4552 /* R_X86_64_IRELATIVE comes last. */
4553 plt_index
= htab
->next_irelative_index
--;
4557 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4559 plt_index
= htab
->next_jump_slot_index
++;
4562 /* Don't fill PLT entry for static executables. */
4563 if (plt
== htab
->elf
.splt
)
4565 /* Put relocation index. */
4566 bfd_put_32 (output_bfd
, plt_index
,
4567 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4568 /* Put offset for jmp .PLT0. */
4569 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ abed
->plt_plt_insn_end
),
4570 plt
->contents
+ h
->plt
.offset
+ abed
->plt_plt_offset
);
4573 bed
= get_elf_backend_data (output_bfd
);
4574 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4575 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4577 if (!h
->def_regular
)
4579 /* Mark the symbol as undefined, rather than as defined in
4580 the .plt section. Leave the value if there were any
4581 relocations where pointer equality matters (this is a clue
4582 for the dynamic linker, to make function pointer
4583 comparisons work between an application and shared
4584 library), otherwise set it to zero. If a function is only
4585 called from a binary, there is no need to slow down
4586 shared libraries because of that. */
4587 sym
->st_shndx
= SHN_UNDEF
;
4588 if (!h
->pointer_equality_needed
)
4593 if (h
->got
.offset
!= (bfd_vma
) -1
4594 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4595 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4597 Elf_Internal_Rela rela
;
4599 /* This symbol has an entry in the global offset table. Set it
4601 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4604 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4605 + htab
->elf
.sgot
->output_offset
4606 + (h
->got
.offset
&~ (bfd_vma
) 1));
4608 /* If this is a static link, or it is a -Bsymbolic link and the
4609 symbol is defined locally or was forced to be local because
4610 of a version file, we just want to emit a RELATIVE reloc.
4611 The entry in the global offset table will already have been
4612 initialized in the relocate_section function. */
4614 && h
->type
== STT_GNU_IFUNC
)
4618 /* Generate R_X86_64_GLOB_DAT. */
4625 if (!h
->pointer_equality_needed
)
4628 /* For non-shared object, we can't use .got.plt, which
4629 contains the real function addres if we need pointer
4630 equality. We load the GOT entry with the PLT entry. */
4631 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4632 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4633 + plt
->output_offset
4635 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4639 else if (info
->shared
4640 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4642 if (!h
->def_regular
)
4644 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4645 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4646 rela
.r_addend
= (h
->root
.u
.def
.value
4647 + h
->root
.u
.def
.section
->output_section
->vma
4648 + h
->root
.u
.def
.section
->output_offset
);
4652 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4654 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4655 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4656 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4660 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4665 Elf_Internal_Rela rela
;
4667 /* This symbol needs a copy reloc. Set it up. */
4669 if (h
->dynindx
== -1
4670 || (h
->root
.type
!= bfd_link_hash_defined
4671 && h
->root
.type
!= bfd_link_hash_defweak
)
4672 || htab
->srelbss
== NULL
)
4675 rela
.r_offset
= (h
->root
.u
.def
.value
4676 + h
->root
.u
.def
.section
->output_section
->vma
4677 + h
->root
.u
.def
.section
->output_offset
);
4678 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4680 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4686 /* Finish up local dynamic symbol handling. We set the contents of
4687 various dynamic sections here. */
4690 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4692 struct elf_link_hash_entry
*h
4693 = (struct elf_link_hash_entry
*) *slot
;
4694 struct bfd_link_info
*info
4695 = (struct bfd_link_info
*) inf
;
4697 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4701 /* Used to decide how to sort relocs in an optimal manner for the
4702 dynamic linker, before writing them out. */
4704 static enum elf_reloc_type_class
4705 elf_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
4707 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4709 case R_X86_64_RELATIVE
:
4710 case R_X86_64_RELATIVE64
:
4711 return reloc_class_relative
;
4712 case R_X86_64_JUMP_SLOT
:
4713 return reloc_class_plt
;
4715 return reloc_class_copy
;
4717 return reloc_class_normal
;
4721 /* Finish up the dynamic sections. */
4724 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4725 struct bfd_link_info
*info
)
4727 struct elf_x86_64_link_hash_table
*htab
;
4730 const struct elf_x86_64_backend_data
*const abed
4731 = get_elf_x86_64_backend_data (output_bfd
);
4733 htab
= elf_x86_64_hash_table (info
);
4737 dynobj
= htab
->elf
.dynobj
;
4738 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4740 if (htab
->elf
.dynamic_sections_created
)
4742 bfd_byte
*dyncon
, *dynconend
;
4743 const struct elf_backend_data
*bed
;
4744 bfd_size_type sizeof_dyn
;
4746 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4749 bed
= get_elf_backend_data (dynobj
);
4750 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4751 dyncon
= sdyn
->contents
;
4752 dynconend
= sdyn
->contents
+ sdyn
->size
;
4753 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4755 Elf_Internal_Dyn dyn
;
4758 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4766 s
= htab
->elf
.sgotplt
;
4767 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4771 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4775 s
= htab
->elf
.srelplt
->output_section
;
4776 dyn
.d_un
.d_val
= s
->size
;
4780 /* The procedure linkage table relocs (DT_JMPREL) should
4781 not be included in the overall relocs (DT_RELA).
4782 Therefore, we override the DT_RELASZ entry here to
4783 make it not include the JMPREL relocs. Since the
4784 linker script arranges for .rela.plt to follow all
4785 other relocation sections, we don't have to worry
4786 about changing the DT_RELA entry. */
4787 if (htab
->elf
.srelplt
!= NULL
)
4789 s
= htab
->elf
.srelplt
->output_section
;
4790 dyn
.d_un
.d_val
-= s
->size
;
4794 case DT_TLSDESC_PLT
:
4796 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4797 + htab
->tlsdesc_plt
;
4800 case DT_TLSDESC_GOT
:
4802 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4803 + htab
->tlsdesc_got
;
4807 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4810 /* Fill in the special first entry in the procedure linkage table. */
4811 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4813 /* Fill in the first entry in the procedure linkage table. */
4814 memcpy (htab
->elf
.splt
->contents
,
4815 abed
->plt0_entry
, abed
->plt_entry_size
);
4816 /* Add offset for pushq GOT+8(%rip), since the instruction
4817 uses 6 bytes subtract this value. */
4818 bfd_put_32 (output_bfd
,
4819 (htab
->elf
.sgotplt
->output_section
->vma
4820 + htab
->elf
.sgotplt
->output_offset
4822 - htab
->elf
.splt
->output_section
->vma
4823 - htab
->elf
.splt
->output_offset
4825 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
4826 /* Add offset for the PC-relative instruction accessing GOT+16,
4827 subtracting the offset to the end of that instruction. */
4828 bfd_put_32 (output_bfd
,
4829 (htab
->elf
.sgotplt
->output_section
->vma
4830 + htab
->elf
.sgotplt
->output_offset
4832 - htab
->elf
.splt
->output_section
->vma
4833 - htab
->elf
.splt
->output_offset
4834 - abed
->plt0_got2_insn_end
),
4835 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
4837 elf_section_data (htab
->elf
.splt
->output_section
)
4838 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
4840 if (htab
->tlsdesc_plt
)
4842 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4843 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4845 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4846 abed
->plt0_entry
, abed
->plt_entry_size
);
4848 /* Add offset for pushq GOT+8(%rip), since the
4849 instruction uses 6 bytes subtract this value. */
4850 bfd_put_32 (output_bfd
,
4851 (htab
->elf
.sgotplt
->output_section
->vma
4852 + htab
->elf
.sgotplt
->output_offset
4854 - htab
->elf
.splt
->output_section
->vma
4855 - htab
->elf
.splt
->output_offset
4858 htab
->elf
.splt
->contents
4859 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
4860 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4861 where TGD stands for htab->tlsdesc_got, subtracting the offset
4862 to the end of that instruction. */
4863 bfd_put_32 (output_bfd
,
4864 (htab
->elf
.sgot
->output_section
->vma
4865 + htab
->elf
.sgot
->output_offset
4867 - htab
->elf
.splt
->output_section
->vma
4868 - htab
->elf
.splt
->output_offset
4870 - abed
->plt0_got2_insn_end
),
4871 htab
->elf
.splt
->contents
4872 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
4877 if (htab
->elf
.sgotplt
)
4879 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4881 (*_bfd_error_handler
)
4882 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4886 /* Fill in the first three entries in the global offset table. */
4887 if (htab
->elf
.sgotplt
->size
> 0)
4889 /* Set the first entry in the global offset table to the address of
4890 the dynamic section. */
4892 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4894 bfd_put_64 (output_bfd
,
4895 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4896 htab
->elf
.sgotplt
->contents
);
4897 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4898 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4899 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4902 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4906 /* Adjust .eh_frame for .plt section. */
4907 if (htab
->plt_eh_frame
!= NULL
4908 && htab
->plt_eh_frame
->contents
!= NULL
)
4910 if (htab
->elf
.splt
!= NULL
4911 && htab
->elf
.splt
->size
!= 0
4912 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
4913 && htab
->elf
.splt
->output_section
!= NULL
4914 && htab
->plt_eh_frame
->output_section
!= NULL
)
4916 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
4917 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
4918 + htab
->plt_eh_frame
->output_offset
4919 + PLT_FDE_START_OFFSET
;
4920 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
4921 htab
->plt_eh_frame
->contents
4922 + PLT_FDE_START_OFFSET
);
4924 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4926 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
4928 htab
->plt_eh_frame
->contents
))
4933 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4934 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4937 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4938 htab_traverse (htab
->loc_hash_table
,
4939 elf_x86_64_finish_local_dynamic_symbol
,
4945 /* Return address for Ith PLT stub in section PLT, for relocation REL
4946 or (bfd_vma) -1 if it should not be included. */
4949 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4950 const arelent
*rel ATTRIBUTE_UNUSED
)
4952 return plt
->vma
+ (i
+ 1) * GET_PLT_ENTRY_SIZE (plt
->owner
);
4955 /* Handle an x86-64 specific section when reading an object file. This
4956 is called when elfcode.h finds a section with an unknown type. */
4959 elf_x86_64_section_from_shdr (bfd
*abfd
,
4960 Elf_Internal_Shdr
*hdr
,
4964 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4967 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4973 /* Hook called by the linker routine which adds symbols from an object
4974 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4978 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4979 struct bfd_link_info
*info
,
4980 Elf_Internal_Sym
*sym
,
4981 const char **namep ATTRIBUTE_UNUSED
,
4982 flagword
*flagsp ATTRIBUTE_UNUSED
,
4988 switch (sym
->st_shndx
)
4990 case SHN_X86_64_LCOMMON
:
4991 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4994 lcomm
= bfd_make_section_with_flags (abfd
,
4998 | SEC_LINKER_CREATED
));
5001 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5004 *valp
= sym
->st_size
;
5008 if ((abfd
->flags
& DYNAMIC
) == 0
5009 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5010 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
5011 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5017 /* Given a BFD section, try to locate the corresponding ELF section
5021 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5022 asection
*sec
, int *index_return
)
5024 if (sec
== &_bfd_elf_large_com_section
)
5026 *index_return
= SHN_X86_64_LCOMMON
;
5032 /* Process a symbol. */
5035 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5038 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5040 switch (elfsym
->internal_elf_sym
.st_shndx
)
5042 case SHN_X86_64_LCOMMON
:
5043 asym
->section
= &_bfd_elf_large_com_section
;
5044 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5045 /* Common symbol doesn't set BSF_GLOBAL. */
5046 asym
->flags
&= ~BSF_GLOBAL
;
5052 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5054 return (sym
->st_shndx
== SHN_COMMON
5055 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5059 elf_x86_64_common_section_index (asection
*sec
)
5061 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5064 return SHN_X86_64_LCOMMON
;
5068 elf_x86_64_common_section (asection
*sec
)
5070 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5071 return bfd_com_section_ptr
;
5073 return &_bfd_elf_large_com_section
;
5077 elf_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5078 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
5079 struct elf_link_hash_entry
*h
,
5080 Elf_Internal_Sym
*sym
,
5082 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
5083 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
5084 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
5085 bfd_boolean
*override ATTRIBUTE_UNUSED
,
5086 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
5087 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
5088 bfd_boolean
*newdyn ATTRIBUTE_UNUSED
,
5089 bfd_boolean
*newdef
,
5090 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
5091 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
5092 bfd
*abfd ATTRIBUTE_UNUSED
,
5094 bfd_boolean
*olddyn ATTRIBUTE_UNUSED
,
5095 bfd_boolean
*olddef
,
5096 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
5097 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
5101 /* A normal common symbol and a large common symbol result in a
5102 normal common symbol. We turn the large common symbol into a
5105 && h
->root
.type
== bfd_link_hash_common
5107 && bfd_is_com_section (*sec
)
5110 if (sym
->st_shndx
== SHN_COMMON
5111 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
5113 h
->root
.u
.c
.p
->section
5114 = bfd_make_section_old_way (oldbfd
, "COMMON");
5115 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5117 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5118 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) == 0)
5119 *psec
= *sec
= bfd_com_section_ptr
;
5126 elf_x86_64_additional_program_headers (bfd
*abfd
,
5127 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5132 /* Check to see if we need a large readonly segment. */
5133 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5134 if (s
&& (s
->flags
& SEC_LOAD
))
5137 /* Check to see if we need a large data segment. Since .lbss sections
5138 is placed right after the .bss section, there should be no need for
5139 a large data segment just because of .lbss. */
5140 s
= bfd_get_section_by_name (abfd
, ".ldata");
5141 if (s
&& (s
->flags
& SEC_LOAD
))
5147 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5150 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5152 if (h
->plt
.offset
!= (bfd_vma
) -1
5154 && !h
->pointer_equality_needed
)
5157 return _bfd_elf_hash_symbol (h
);
5160 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5163 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5164 const bfd_target
*output
)
5166 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5167 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5168 && _bfd_elf_relocs_compatible (input
, output
));
5171 static const struct bfd_elf_special_section
5172 elf_x86_64_special_sections
[]=
5174 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5175 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5176 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5177 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5178 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5179 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5180 { NULL
, 0, 0, 0, 0 }
5183 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5184 #define TARGET_LITTLE_NAME "elf64-x86-64"
5185 #define ELF_ARCH bfd_arch_i386
5186 #define ELF_TARGET_ID X86_64_ELF_DATA
5187 #define ELF_MACHINE_CODE EM_X86_64
5188 #define ELF_MAXPAGESIZE 0x200000
5189 #define ELF_MINPAGESIZE 0x1000
5190 #define ELF_COMMONPAGESIZE 0x1000
5192 #define elf_backend_can_gc_sections 1
5193 #define elf_backend_can_refcount 1
5194 #define elf_backend_want_got_plt 1
5195 #define elf_backend_plt_readonly 1
5196 #define elf_backend_want_plt_sym 0
5197 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5198 #define elf_backend_rela_normal 1
5199 #define elf_backend_plt_alignment 4
5201 #define elf_info_to_howto elf_x86_64_info_to_howto
5203 #define bfd_elf64_bfd_link_hash_table_create \
5204 elf_x86_64_link_hash_table_create
5205 #define bfd_elf64_bfd_link_hash_table_free \
5206 elf_x86_64_link_hash_table_free
5207 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5208 #define bfd_elf64_bfd_reloc_name_lookup \
5209 elf_x86_64_reloc_name_lookup
5211 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5212 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5213 #define elf_backend_check_relocs elf_x86_64_check_relocs
5214 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5215 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5216 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5217 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5218 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5219 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5220 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5221 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5223 #define elf_backend_write_core_note elf_x86_64_write_core_note
5225 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5226 #define elf_backend_relocate_section elf_x86_64_relocate_section
5227 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5228 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5229 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5230 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5231 #define elf_backend_object_p elf64_x86_64_elf_object_p
5232 #define bfd_elf64_mkobject elf_x86_64_mkobject
5234 #define elf_backend_section_from_shdr \
5235 elf_x86_64_section_from_shdr
5237 #define elf_backend_section_from_bfd_section \
5238 elf_x86_64_elf_section_from_bfd_section
5239 #define elf_backend_add_symbol_hook \
5240 elf_x86_64_add_symbol_hook
5241 #define elf_backend_symbol_processing \
5242 elf_x86_64_symbol_processing
5243 #define elf_backend_common_section_index \
5244 elf_x86_64_common_section_index
5245 #define elf_backend_common_section \
5246 elf_x86_64_common_section
5247 #define elf_backend_common_definition \
5248 elf_x86_64_common_definition
5249 #define elf_backend_merge_symbol \
5250 elf_x86_64_merge_symbol
5251 #define elf_backend_special_sections \
5252 elf_x86_64_special_sections
5253 #define elf_backend_additional_program_headers \
5254 elf_x86_64_additional_program_headers
5255 #define elf_backend_hash_symbol \
5256 elf_x86_64_hash_symbol
5258 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5260 #include "elf64-target.h"
5262 /* FreeBSD support. */
5264 #undef TARGET_LITTLE_SYM
5265 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5266 #undef TARGET_LITTLE_NAME
5267 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5270 #define ELF_OSABI ELFOSABI_FREEBSD
5273 #define elf64_bed elf64_x86_64_fbsd_bed
5275 #include "elf64-target.h"
5277 /* Solaris 2 support. */
5279 #undef TARGET_LITTLE_SYM
5280 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5281 #undef TARGET_LITTLE_NAME
5282 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5284 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5285 objects won't be recognized. */
5289 #define elf64_bed elf64_x86_64_sol2_bed
5291 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5293 #undef elf_backend_static_tls_alignment
5294 #define elf_backend_static_tls_alignment 16
5296 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5298 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5300 #undef elf_backend_want_plt_sym
5301 #define elf_backend_want_plt_sym 1
5303 #include "elf64-target.h"
5305 /* Native Client support. */
5307 #undef TARGET_LITTLE_SYM
5308 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5309 #undef TARGET_LITTLE_NAME
5310 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5312 #define elf64_bed elf64_x86_64_nacl_bed
5314 #undef ELF_MAXPAGESIZE
5315 #undef ELF_MINPAGESIZE
5316 #undef ELF_COMMONPAGESIZE
5317 #define ELF_MAXPAGESIZE 0x10000
5318 #define ELF_MINPAGESIZE 0x10000
5319 #define ELF_COMMONPAGESIZE 0x10000
5321 /* Restore defaults. */
5323 #undef elf_backend_static_tls_alignment
5324 #undef elf_backend_want_plt_sym
5325 #define elf_backend_want_plt_sym 0
5327 /* NaCl uses substantially different PLT entries for the same effects. */
5329 #undef elf_backend_plt_alignment
5330 #define elf_backend_plt_alignment 5
5331 #define NACL_PLT_ENTRY_SIZE 64
5332 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5334 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5336 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5337 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5338 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5339 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5340 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5342 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5343 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5345 /* 32 bytes of nop to pad out to the standard size. */
5346 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5347 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5348 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5349 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5350 0x66, /* excess data32 prefix */
5354 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5356 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5357 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5358 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5359 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5361 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5362 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5363 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5365 /* Lazy GOT entries point here (32-byte aligned). */
5366 0x68, /* pushq immediate */
5367 0, 0, 0, 0, /* replaced with index into relocation table. */
5368 0xe9, /* jmp relative */
5369 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5371 /* 22 bytes of nop to pad out to the standard size. */
5372 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5373 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5374 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5377 /* .eh_frame covering the .plt section. */
5379 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5381 #if (PLT_CIE_LENGTH != 20 \
5382 || PLT_FDE_LENGTH != 36 \
5383 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5384 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5385 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5387 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5388 0, 0, 0, 0, /* CIE ID */
5389 1, /* CIE version */
5390 'z', 'R', 0, /* Augmentation string */
5391 1, /* Code alignment factor */
5392 0x78, /* Data alignment factor */
5393 16, /* Return address column */
5394 1, /* Augmentation size */
5395 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5396 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5397 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5398 DW_CFA_nop
, DW_CFA_nop
,
5400 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5401 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5402 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5403 0, 0, 0, 0, /* .plt size goes here */
5404 0, /* Augmentation size */
5405 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5406 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5407 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5408 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5409 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5410 13, /* Block length */
5411 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5412 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5413 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5414 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5415 DW_CFA_nop
, DW_CFA_nop
5418 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5420 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5421 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5422 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5423 2, /* plt0_got1_offset */
5424 9, /* plt0_got2_offset */
5425 13, /* plt0_got2_insn_end */
5426 3, /* plt_got_offset */
5427 33, /* plt_reloc_offset */
5428 38, /* plt_plt_offset */
5429 7, /* plt_got_insn_size */
5430 42, /* plt_plt_insn_end */
5431 32, /* plt_lazy_offset */
5432 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5433 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5436 #undef elf_backend_arch_data
5437 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5439 #undef elf_backend_modify_segment_map
5440 #define elf_backend_modify_segment_map nacl_modify_segment_map
5441 #undef elf_backend_modify_program_headers
5442 #define elf_backend_modify_program_headers nacl_modify_program_headers
5444 #include "elf64-target.h"
5446 /* Native Client x32 support. */
5448 #undef TARGET_LITTLE_SYM
5449 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5450 #undef TARGET_LITTLE_NAME
5451 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5453 #define elf32_bed elf32_x86_64_nacl_bed
5455 #define bfd_elf32_bfd_link_hash_table_create \
5456 elf_x86_64_link_hash_table_create
5457 #define bfd_elf32_bfd_link_hash_table_free \
5458 elf_x86_64_link_hash_table_free
5459 #define bfd_elf32_bfd_reloc_type_lookup \
5460 elf_x86_64_reloc_type_lookup
5461 #define bfd_elf32_bfd_reloc_name_lookup \
5462 elf_x86_64_reloc_name_lookup
5463 #define bfd_elf32_mkobject \
5466 #undef elf_backend_object_p
5467 #define elf_backend_object_p \
5468 elf32_x86_64_elf_object_p
5470 #undef elf_backend_bfd_from_remote_memory
5471 #define elf_backend_bfd_from_remote_memory \
5472 _bfd_elf32_bfd_from_remote_memory
5474 #undef elf_backend_size_info
5475 #define elf_backend_size_info \
5476 _bfd_elf32_size_info
5478 #include "elf32-target.h"
5480 /* Restore defaults. */
5481 #undef elf_backend_object_p
5482 #define elf_backend_object_p elf64_x86_64_elf_object_p
5483 #undef elf_backend_bfd_from_remote_memory
5484 #undef elf_backend_size_info
5485 #undef elf_backend_modify_segment_map
5486 #undef elf_backend_modify_program_headers
5488 /* Intel L1OM support. */
5491 elf64_l1om_elf_object_p (bfd
*abfd
)
5493 /* Set the right machine number for an L1OM elf64 file. */
5494 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
5498 #undef TARGET_LITTLE_SYM
5499 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5500 #undef TARGET_LITTLE_NAME
5501 #define TARGET_LITTLE_NAME "elf64-l1om"
5503 #define ELF_ARCH bfd_arch_l1om
5505 #undef ELF_MACHINE_CODE
5506 #define ELF_MACHINE_CODE EM_L1OM
5511 #define elf64_bed elf64_l1om_bed
5513 #undef elf_backend_object_p
5514 #define elf_backend_object_p elf64_l1om_elf_object_p
5516 /* Restore defaults. */
5517 #undef ELF_MAXPAGESIZE
5518 #undef ELF_MINPAGESIZE
5519 #undef ELF_COMMONPAGESIZE
5520 #define ELF_MAXPAGESIZE 0x200000
5521 #define ELF_MINPAGESIZE 0x1000
5522 #define ELF_COMMONPAGESIZE 0x1000
5523 #undef elf_backend_plt_alignment
5524 #define elf_backend_plt_alignment 4
5525 #undef elf_backend_arch_data
5526 #define elf_backend_arch_data &elf_x86_64_arch_bed
5528 #include "elf64-target.h"
5530 /* FreeBSD L1OM support. */
5532 #undef TARGET_LITTLE_SYM
5533 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5534 #undef TARGET_LITTLE_NAME
5535 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5538 #define ELF_OSABI ELFOSABI_FREEBSD
5541 #define elf64_bed elf64_l1om_fbsd_bed
5543 #include "elf64-target.h"
5545 /* Intel K1OM support. */
5548 elf64_k1om_elf_object_p (bfd
*abfd
)
5550 /* Set the right machine number for an K1OM elf64 file. */
5551 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
5555 #undef TARGET_LITTLE_SYM
5556 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5557 #undef TARGET_LITTLE_NAME
5558 #define TARGET_LITTLE_NAME "elf64-k1om"
5560 #define ELF_ARCH bfd_arch_k1om
5562 #undef ELF_MACHINE_CODE
5563 #define ELF_MACHINE_CODE EM_K1OM
5568 #define elf64_bed elf64_k1om_bed
5570 #undef elf_backend_object_p
5571 #define elf_backend_object_p elf64_k1om_elf_object_p
5573 #undef elf_backend_static_tls_alignment
5575 #undef elf_backend_want_plt_sym
5576 #define elf_backend_want_plt_sym 0
5578 #include "elf64-target.h"
5580 /* FreeBSD K1OM support. */
5582 #undef TARGET_LITTLE_SYM
5583 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5584 #undef TARGET_LITTLE_NAME
5585 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5588 #define ELF_OSABI ELFOSABI_FREEBSD
5591 #define elf64_bed elf64_k1om_fbsd_bed
5593 #include "elf64-target.h"
5595 /* 32bit x86-64 support. */
5597 #undef TARGET_LITTLE_SYM
5598 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5599 #undef TARGET_LITTLE_NAME
5600 #define TARGET_LITTLE_NAME "elf32-x86-64"
5604 #define ELF_ARCH bfd_arch_i386
5606 #undef ELF_MACHINE_CODE
5607 #define ELF_MACHINE_CODE EM_X86_64
5611 #undef elf_backend_object_p
5612 #define elf_backend_object_p \
5613 elf32_x86_64_elf_object_p
5615 #undef elf_backend_bfd_from_remote_memory
5616 #define elf_backend_bfd_from_remote_memory \
5617 _bfd_elf32_bfd_from_remote_memory
5619 #undef elf_backend_size_info
5620 #define elf_backend_size_info \
5621 _bfd_elf32_size_info
5623 #include "elf32-target.h"