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
,
153 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
154 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
155 "R_X86_64_GOTPC32_TLSDESC",
156 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
157 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
158 complain_overflow_dont
, bfd_elf_generic_reloc
,
159 "R_X86_64_TLSDESC_CALL",
161 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
162 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
164 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
165 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
166 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
168 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
172 /* We have a gap in the reloc numbers here.
173 R_X86_64_standard counts the number up to this point, and
174 R_X86_64_vt_offset is the value to subtract from a reloc type of
175 R_X86_64_GNU_VT* to form an index into this table. */
176 #define R_X86_64_standard (R_X86_64_RELATIVE64 + 1)
177 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
179 /* GNU extension to record C++ vtable hierarchy. */
180 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
181 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
183 /* GNU extension to record C++ vtable member usage. */
184 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
185 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
188 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
189 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
190 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
194 #define IS_X86_64_PCREL_TYPE(TYPE) \
195 ( ((TYPE) == R_X86_64_PC8) \
196 || ((TYPE) == R_X86_64_PC16) \
197 || ((TYPE) == R_X86_64_PC32) \
198 || ((TYPE) == R_X86_64_PC64))
200 /* Map BFD relocs to the x86_64 elf relocs. */
203 bfd_reloc_code_real_type bfd_reloc_val
;
204 unsigned char elf_reloc_val
;
207 static const struct elf_reloc_map x86_64_reloc_map
[] =
209 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
210 { BFD_RELOC_64
, R_X86_64_64
, },
211 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
212 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
213 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
214 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
215 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
216 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
217 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
218 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
219 { BFD_RELOC_32
, R_X86_64_32
, },
220 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
221 { BFD_RELOC_16
, R_X86_64_16
, },
222 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
223 { BFD_RELOC_8
, R_X86_64_8
, },
224 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
225 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
226 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
227 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
228 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
229 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
230 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
231 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
232 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
233 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
234 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
235 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
236 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
237 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
238 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
239 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
240 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
241 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
242 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
243 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
244 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
245 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
246 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
249 static reloc_howto_type
*
250 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
254 if (r_type
== (unsigned int) R_X86_64_32
)
259 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
261 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
262 || r_type
>= (unsigned int) R_X86_64_max
)
264 if (r_type
>= (unsigned int) R_X86_64_standard
)
266 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
268 r_type
= R_X86_64_NONE
;
273 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
274 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
275 return &x86_64_elf_howto_table
[i
];
278 /* Given a BFD reloc type, return a HOWTO structure. */
279 static reloc_howto_type
*
280 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
281 bfd_reloc_code_real_type code
)
285 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
288 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
289 return elf_x86_64_rtype_to_howto (abfd
,
290 x86_64_reloc_map
[i
].elf_reloc_val
);
295 static reloc_howto_type
*
296 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
301 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
303 /* Get x32 R_X86_64_32. */
304 reloc_howto_type
*reloc
305 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
306 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
310 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
311 if (x86_64_elf_howto_table
[i
].name
!= NULL
312 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
313 return &x86_64_elf_howto_table
[i
];
318 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
321 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
322 Elf_Internal_Rela
*dst
)
326 r_type
= ELF32_R_TYPE (dst
->r_info
);
327 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
328 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
331 /* Support for core dump NOTE sections. */
333 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
338 switch (note
->descsz
)
343 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
345 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
348 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
356 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
358 elf_tdata (abfd
)->core_signal
359 = bfd_get_16 (abfd
, note
->descdata
+ 12);
362 elf_tdata (abfd
)->core_lwpid
363 = bfd_get_32 (abfd
, note
->descdata
+ 32);
372 /* Make a ".reg/999" section. */
373 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
374 size
, note
->descpos
+ offset
);
378 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
380 switch (note
->descsz
)
385 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
386 elf_tdata (abfd
)->core_pid
387 = bfd_get_32 (abfd
, note
->descdata
+ 12);
388 elf_tdata (abfd
)->core_program
389 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
390 elf_tdata (abfd
)->core_command
391 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
394 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
395 elf_tdata (abfd
)->core_pid
396 = bfd_get_32 (abfd
, note
->descdata
+ 24);
397 elf_tdata (abfd
)->core_program
398 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
399 elf_tdata (abfd
)->core_command
400 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
403 /* Note that for some reason, a spurious space is tacked
404 onto the end of the args in some (at least one anyway)
405 implementations, so strip it off if it exists. */
408 char *command
= elf_tdata (abfd
)->core_command
;
409 int n
= strlen (command
);
411 if (0 < n
&& command
[n
- 1] == ' ')
412 command
[n
- 1] = '\0';
420 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
423 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
425 const char *fname
, *psargs
;
436 va_start (ap
, note_type
);
437 fname
= va_arg (ap
, const char *);
438 psargs
= va_arg (ap
, const char *);
441 if (bed
->s
->elfclass
== ELFCLASS32
)
444 memset (&data
, 0, sizeof (data
));
445 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
446 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
447 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
448 &data
, sizeof (data
));
453 memset (&data
, 0, sizeof (data
));
454 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
455 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
456 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
457 &data
, sizeof (data
));
462 va_start (ap
, note_type
);
463 pid
= va_arg (ap
, long);
464 cursig
= va_arg (ap
, int);
465 gregs
= va_arg (ap
, const void *);
468 if (bed
->s
->elfclass
== ELFCLASS32
)
470 if (bed
->elf_machine_code
== EM_X86_64
)
472 prstatusx32_t prstat
;
473 memset (&prstat
, 0, sizeof (prstat
));
475 prstat
.pr_cursig
= cursig
;
476 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
477 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
478 &prstat
, sizeof (prstat
));
483 memset (&prstat
, 0, sizeof (prstat
));
485 prstat
.pr_cursig
= cursig
;
486 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
487 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
488 &prstat
, sizeof (prstat
));
494 memset (&prstat
, 0, sizeof (prstat
));
496 prstat
.pr_cursig
= cursig
;
497 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
498 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
499 &prstat
, sizeof (prstat
));
506 /* Functions for the x86-64 ELF linker. */
508 /* The name of the dynamic interpreter. This is put in the .interp
511 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
512 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
514 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
515 copying dynamic variables from a shared lib into an app's dynbss
516 section, and instead use a dynamic relocation to point into the
518 #define ELIMINATE_COPY_RELOCS 1
520 /* The size in bytes of an entry in the global offset table. */
522 #define GOT_ENTRY_SIZE 8
524 /* The size in bytes of an entry in the procedure linkage table. */
526 #define PLT_ENTRY_SIZE 16
528 /* The first entry in a procedure linkage table looks like this. See the
529 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
531 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
533 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
534 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
535 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
538 /* Subsequent entries in a procedure linkage table look like this. */
540 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
542 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
543 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
544 0x68, /* pushq immediate */
545 0, 0, 0, 0, /* replaced with index into relocation table. */
546 0xe9, /* jmp relative */
547 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
550 /* .eh_frame covering the .plt section. */
552 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
554 #define PLT_CIE_LENGTH 20
555 #define PLT_FDE_LENGTH 36
556 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
557 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
558 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
559 0, 0, 0, 0, /* CIE ID */
561 'z', 'R', 0, /* Augmentation string */
562 1, /* Code alignment factor */
563 0x78, /* Data alignment factor */
564 16, /* Return address column */
565 1, /* Augmentation size */
566 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
567 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
568 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
569 DW_CFA_nop
, DW_CFA_nop
,
571 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
572 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
573 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
574 0, 0, 0, 0, /* .plt size goes here */
575 0, /* Augmentation size */
576 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
577 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
578 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
579 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
580 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
581 11, /* Block length */
582 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
583 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
584 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
585 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
586 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
589 /* Architecture-specific backend data for x86-64. */
591 struct elf_x86_64_backend_data
593 /* Templates for the initial PLT entry and for subsequent entries. */
594 const bfd_byte
*plt0_entry
;
595 const bfd_byte
*plt_entry
;
596 unsigned int plt_entry_size
; /* Size of each PLT entry. */
598 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
599 unsigned int plt0_got1_offset
;
600 unsigned int plt0_got2_offset
;
602 /* Offset of the end of the PC-relative instruction containing
604 unsigned int plt0_got2_insn_end
;
606 /* Offsets into plt_entry that are to be replaced with... */
607 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
608 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
609 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
611 /* Length of the PC-relative instruction containing plt_got_offset. */
612 unsigned int plt_got_insn_size
;
614 /* Offset of the end of the PC-relative jump to plt0_entry. */
615 unsigned int plt_plt_insn_end
;
617 /* Offset into plt_entry where the initial value of the GOT entry points. */
618 unsigned int plt_lazy_offset
;
620 /* .eh_frame covering the .plt section. */
621 const bfd_byte
*eh_frame_plt
;
622 unsigned int eh_frame_plt_size
;
625 #define get_elf_x86_64_backend_data(abfd) \
626 ((const struct elf_x86_64_backend_data *) \
627 get_elf_backend_data (abfd)->arch_data)
629 #define GET_PLT_ENTRY_SIZE(abfd) \
630 get_elf_x86_64_backend_data (abfd)->plt_entry_size
632 /* These are the standard parameters. */
633 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
635 elf_x86_64_plt0_entry
, /* plt0_entry */
636 elf_x86_64_plt_entry
, /* plt_entry */
637 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
638 2, /* plt0_got1_offset */
639 8, /* plt0_got2_offset */
640 12, /* plt0_got2_insn_end */
641 2, /* plt_got_offset */
642 7, /* plt_reloc_offset */
643 12, /* plt_plt_offset */
644 6, /* plt_got_insn_size */
645 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
646 6, /* plt_lazy_offset */
647 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
648 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
651 #define elf_backend_arch_data &elf_x86_64_arch_bed
653 /* x86-64 ELF linker hash entry. */
655 struct elf_x86_64_link_hash_entry
657 struct elf_link_hash_entry elf
;
659 /* Track dynamic relocs copied for this symbol. */
660 struct elf_dyn_relocs
*dyn_relocs
;
662 #define GOT_UNKNOWN 0
666 #define GOT_TLS_GDESC 4
667 #define GOT_TLS_GD_BOTH_P(type) \
668 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
669 #define GOT_TLS_GD_P(type) \
670 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
671 #define GOT_TLS_GDESC_P(type) \
672 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
673 #define GOT_TLS_GD_ANY_P(type) \
674 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
675 unsigned char tls_type
;
677 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
678 starting at the end of the jump table. */
682 #define elf_x86_64_hash_entry(ent) \
683 ((struct elf_x86_64_link_hash_entry *)(ent))
685 struct elf_x86_64_obj_tdata
687 struct elf_obj_tdata root
;
689 /* tls_type for each local got entry. */
690 char *local_got_tls_type
;
692 /* GOTPLT entries for TLS descriptors. */
693 bfd_vma
*local_tlsdesc_gotent
;
696 #define elf_x86_64_tdata(abfd) \
697 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
699 #define elf_x86_64_local_got_tls_type(abfd) \
700 (elf_x86_64_tdata (abfd)->local_got_tls_type)
702 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
703 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
705 #define is_x86_64_elf(bfd) \
706 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
707 && elf_tdata (bfd) != NULL \
708 && elf_object_id (bfd) == X86_64_ELF_DATA)
711 elf_x86_64_mkobject (bfd
*abfd
)
713 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
717 /* x86-64 ELF linker hash table. */
719 struct elf_x86_64_link_hash_table
721 struct elf_link_hash_table elf
;
723 /* Short-cuts to get to dynamic linker sections. */
726 asection
*plt_eh_frame
;
730 bfd_signed_vma refcount
;
734 /* The amount of space used by the jump slots in the GOT. */
735 bfd_vma sgotplt_jump_table_size
;
737 /* Small local sym cache. */
738 struct sym_cache sym_cache
;
740 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
741 bfd_vma (*r_sym
) (bfd_vma
);
742 unsigned int pointer_r_type
;
743 const char *dynamic_interpreter
;
744 int dynamic_interpreter_size
;
746 /* _TLS_MODULE_BASE_ symbol. */
747 struct bfd_link_hash_entry
*tls_module_base
;
749 /* Used by local STT_GNU_IFUNC symbols. */
750 htab_t loc_hash_table
;
751 void * loc_hash_memory
;
753 /* The offset into splt of the PLT entry for the TLS descriptor
754 resolver. Special values are 0, if not necessary (or not found
755 to be necessary yet), and -1 if needed but not determined
758 /* The offset into sgot of the GOT entry used by the PLT entry
762 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
763 bfd_vma next_jump_slot_index
;
764 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
765 bfd_vma next_irelative_index
;
768 /* Get the x86-64 ELF linker hash table from a link_info structure. */
770 #define elf_x86_64_hash_table(p) \
771 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
772 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
774 #define elf_x86_64_compute_jump_table_size(htab) \
775 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
777 /* Create an entry in an x86-64 ELF linker hash table. */
779 static struct bfd_hash_entry
*
780 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
781 struct bfd_hash_table
*table
,
784 /* Allocate the structure if it has not already been allocated by a
788 entry
= (struct bfd_hash_entry
*)
789 bfd_hash_allocate (table
,
790 sizeof (struct elf_x86_64_link_hash_entry
));
795 /* Call the allocation method of the superclass. */
796 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
799 struct elf_x86_64_link_hash_entry
*eh
;
801 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
802 eh
->dyn_relocs
= NULL
;
803 eh
->tls_type
= GOT_UNKNOWN
;
804 eh
->tlsdesc_got
= (bfd_vma
) -1;
810 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
811 for local symbol so that we can handle local STT_GNU_IFUNC symbols
812 as global symbol. We reuse indx and dynstr_index for local symbol
813 hash since they aren't used by global symbols in this backend. */
816 elf_x86_64_local_htab_hash (const void *ptr
)
818 struct elf_link_hash_entry
*h
819 = (struct elf_link_hash_entry
*) ptr
;
820 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
823 /* Compare local hash entries. */
826 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
828 struct elf_link_hash_entry
*h1
829 = (struct elf_link_hash_entry
*) ptr1
;
830 struct elf_link_hash_entry
*h2
831 = (struct elf_link_hash_entry
*) ptr2
;
833 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
836 /* Find and/or create a hash entry for local symbol. */
838 static struct elf_link_hash_entry
*
839 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
840 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
843 struct elf_x86_64_link_hash_entry e
, *ret
;
844 asection
*sec
= abfd
->sections
;
845 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
846 htab
->r_sym (rel
->r_info
));
849 e
.elf
.indx
= sec
->id
;
850 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
851 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
852 create
? INSERT
: NO_INSERT
);
859 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
863 ret
= (struct elf_x86_64_link_hash_entry
*)
864 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
865 sizeof (struct elf_x86_64_link_hash_entry
));
868 memset (ret
, 0, sizeof (*ret
));
869 ret
->elf
.indx
= sec
->id
;
870 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
871 ret
->elf
.dynindx
= -1;
877 /* Create an X86-64 ELF linker hash table. */
879 static struct bfd_link_hash_table
*
880 elf_x86_64_link_hash_table_create (bfd
*abfd
)
882 struct elf_x86_64_link_hash_table
*ret
;
883 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
885 ret
= (struct elf_x86_64_link_hash_table
*) bfd_malloc (amt
);
889 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
890 elf_x86_64_link_hash_newfunc
,
891 sizeof (struct elf_x86_64_link_hash_entry
),
900 ret
->plt_eh_frame
= NULL
;
901 ret
->sym_cache
.abfd
= NULL
;
902 ret
->tlsdesc_plt
= 0;
903 ret
->tlsdesc_got
= 0;
904 ret
->tls_ld_got
.refcount
= 0;
905 ret
->sgotplt_jump_table_size
= 0;
906 ret
->tls_module_base
= NULL
;
907 ret
->next_jump_slot_index
= 0;
908 ret
->next_irelative_index
= 0;
912 ret
->r_info
= elf64_r_info
;
913 ret
->r_sym
= elf64_r_sym
;
914 ret
->pointer_r_type
= R_X86_64_64
;
915 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
916 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
920 ret
->r_info
= elf32_r_info
;
921 ret
->r_sym
= elf32_r_sym
;
922 ret
->pointer_r_type
= R_X86_64_32
;
923 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
924 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
927 ret
->loc_hash_table
= htab_try_create (1024,
928 elf_x86_64_local_htab_hash
,
929 elf_x86_64_local_htab_eq
,
931 ret
->loc_hash_memory
= objalloc_create ();
932 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
938 return &ret
->elf
.root
;
941 /* Destroy an X86-64 ELF linker hash table. */
944 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
946 struct elf_x86_64_link_hash_table
*htab
947 = (struct elf_x86_64_link_hash_table
*) hash
;
949 if (htab
->loc_hash_table
)
950 htab_delete (htab
->loc_hash_table
);
951 if (htab
->loc_hash_memory
)
952 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
953 _bfd_generic_link_hash_table_free (hash
);
956 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
957 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
961 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
962 struct bfd_link_info
*info
)
964 struct elf_x86_64_link_hash_table
*htab
;
966 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
969 htab
= elf_x86_64_hash_table (info
);
973 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
975 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
978 || (!info
->shared
&& !htab
->srelbss
))
981 if (!info
->no_ld_generated_unwind_info
982 && htab
->plt_eh_frame
== NULL
983 && htab
->elf
.splt
!= NULL
)
985 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
986 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
987 | SEC_LINKER_CREATED
);
989 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
990 if (htab
->plt_eh_frame
== NULL
991 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
997 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1000 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1001 struct elf_link_hash_entry
*dir
,
1002 struct elf_link_hash_entry
*ind
)
1004 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1006 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1007 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1009 if (eind
->dyn_relocs
!= NULL
)
1011 if (edir
->dyn_relocs
!= NULL
)
1013 struct elf_dyn_relocs
**pp
;
1014 struct elf_dyn_relocs
*p
;
1016 /* Add reloc counts against the indirect sym to the direct sym
1017 list. Merge any entries against the same section. */
1018 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1020 struct elf_dyn_relocs
*q
;
1022 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1023 if (q
->sec
== p
->sec
)
1025 q
->pc_count
+= p
->pc_count
;
1026 q
->count
+= p
->count
;
1033 *pp
= edir
->dyn_relocs
;
1036 edir
->dyn_relocs
= eind
->dyn_relocs
;
1037 eind
->dyn_relocs
= NULL
;
1040 if (ind
->root
.type
== bfd_link_hash_indirect
1041 && dir
->got
.refcount
<= 0)
1043 edir
->tls_type
= eind
->tls_type
;
1044 eind
->tls_type
= GOT_UNKNOWN
;
1047 if (ELIMINATE_COPY_RELOCS
1048 && ind
->root
.type
!= bfd_link_hash_indirect
1049 && dir
->dynamic_adjusted
)
1051 /* If called to transfer flags for a weakdef during processing
1052 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1053 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1054 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1055 dir
->ref_regular
|= ind
->ref_regular
;
1056 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1057 dir
->needs_plt
|= ind
->needs_plt
;
1058 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1061 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1065 elf64_x86_64_elf_object_p (bfd
*abfd
)
1067 /* Set the right machine number for an x86-64 elf64 file. */
1068 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1073 elf32_x86_64_elf_object_p (bfd
*abfd
)
1075 /* Set the right machine number for an x86-64 elf32 file. */
1076 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1080 /* Return TRUE if the TLS access code sequence support transition
1084 elf_x86_64_check_tls_transition (bfd
*abfd
,
1085 struct bfd_link_info
*info
,
1088 Elf_Internal_Shdr
*symtab_hdr
,
1089 struct elf_link_hash_entry
**sym_hashes
,
1090 unsigned int r_type
,
1091 const Elf_Internal_Rela
*rel
,
1092 const Elf_Internal_Rela
*relend
)
1095 unsigned long r_symndx
;
1096 struct elf_link_hash_entry
*h
;
1098 struct elf_x86_64_link_hash_table
*htab
;
1100 /* Get the section contents. */
1101 if (contents
== NULL
)
1103 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1104 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1107 /* FIXME: How to better handle error condition? */
1108 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1111 /* Cache the section contents for elf_link_input_bfd. */
1112 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1116 htab
= elf_x86_64_hash_table (info
);
1117 offset
= rel
->r_offset
;
1120 case R_X86_64_TLSGD
:
1121 case R_X86_64_TLSLD
:
1122 if ((rel
+ 1) >= relend
)
1125 if (r_type
== R_X86_64_TLSGD
)
1127 /* Check transition from GD access model. For 64bit, only
1128 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1129 .word 0x6666; rex64; call __tls_get_addr
1130 can transit to different access model. For 32bit, only
1131 leaq foo@tlsgd(%rip), %rdi
1132 .word 0x6666; rex64; call __tls_get_addr
1133 can transit to different access model. */
1135 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1136 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1138 if ((offset
+ 12) > sec
->size
1139 || memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1142 if (ABI_64_P (abfd
))
1145 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1151 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1157 /* Check transition from LD access model. Only
1158 leaq foo@tlsld(%rip), %rdi;
1160 can transit to different access model. */
1162 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1164 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1167 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0
1168 || 0xe8 != *(contents
+ offset
+ 4))
1172 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1173 if (r_symndx
< symtab_hdr
->sh_info
)
1176 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1177 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1178 may be versioned. */
1180 && h
->root
.root
.string
!= NULL
1181 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1182 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
1183 && (strncmp (h
->root
.root
.string
,
1184 "__tls_get_addr", 14) == 0));
1186 case R_X86_64_GOTTPOFF
:
1187 /* Check transition from IE access model:
1188 mov foo@gottpoff(%rip), %reg
1189 add foo@gottpoff(%rip), %reg
1192 /* Check REX prefix first. */
1193 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1195 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1196 if (val
!= 0x48 && val
!= 0x4c)
1198 /* X32 may have 0x44 REX prefix or no REX prefix. */
1199 if (ABI_64_P (abfd
))
1205 /* X32 may not have any REX prefix. */
1206 if (ABI_64_P (abfd
))
1208 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1212 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1213 if (val
!= 0x8b && val
!= 0x03)
1216 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1217 return (val
& 0xc7) == 5;
1219 case R_X86_64_GOTPC32_TLSDESC
:
1220 /* Check transition from GDesc access model:
1221 leaq x@tlsdesc(%rip), %rax
1223 Make sure it's a leaq adding rip to a 32-bit offset
1224 into any register, although it's probably almost always
1227 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1230 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1231 if ((val
& 0xfb) != 0x48)
1234 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1237 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1238 return (val
& 0xc7) == 0x05;
1240 case R_X86_64_TLSDESC_CALL
:
1241 /* Check transition from GDesc access model:
1242 call *x@tlsdesc(%rax)
1244 if (offset
+ 2 <= sec
->size
)
1246 /* Make sure that it's a call *x@tlsdesc(%rax). */
1247 static const unsigned char call
[] = { 0xff, 0x10 };
1248 return memcmp (contents
+ offset
, call
, 2) == 0;
1258 /* Return TRUE if the TLS access transition is OK or no transition
1259 will be performed. Update R_TYPE if there is a transition. */
1262 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1263 asection
*sec
, bfd_byte
*contents
,
1264 Elf_Internal_Shdr
*symtab_hdr
,
1265 struct elf_link_hash_entry
**sym_hashes
,
1266 unsigned int *r_type
, int tls_type
,
1267 const Elf_Internal_Rela
*rel
,
1268 const Elf_Internal_Rela
*relend
,
1269 struct elf_link_hash_entry
*h
,
1270 unsigned long r_symndx
)
1272 unsigned int from_type
= *r_type
;
1273 unsigned int to_type
= from_type
;
1274 bfd_boolean check
= TRUE
;
1276 /* Skip TLS transition for functions. */
1278 && (h
->type
== STT_FUNC
1279 || h
->type
== STT_GNU_IFUNC
))
1284 case R_X86_64_TLSGD
:
1285 case R_X86_64_GOTPC32_TLSDESC
:
1286 case R_X86_64_TLSDESC_CALL
:
1287 case R_X86_64_GOTTPOFF
:
1288 if (info
->executable
)
1291 to_type
= R_X86_64_TPOFF32
;
1293 to_type
= R_X86_64_GOTTPOFF
;
1296 /* When we are called from elf_x86_64_relocate_section,
1297 CONTENTS isn't NULL and there may be additional transitions
1298 based on TLS_TYPE. */
1299 if (contents
!= NULL
)
1301 unsigned int new_to_type
= to_type
;
1303 if (info
->executable
1306 && tls_type
== GOT_TLS_IE
)
1307 new_to_type
= R_X86_64_TPOFF32
;
1309 if (to_type
== R_X86_64_TLSGD
1310 || to_type
== R_X86_64_GOTPC32_TLSDESC
1311 || to_type
== R_X86_64_TLSDESC_CALL
)
1313 if (tls_type
== GOT_TLS_IE
)
1314 new_to_type
= R_X86_64_GOTTPOFF
;
1317 /* We checked the transition before when we were called from
1318 elf_x86_64_check_relocs. We only want to check the new
1319 transition which hasn't been checked before. */
1320 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1321 to_type
= new_to_type
;
1326 case R_X86_64_TLSLD
:
1327 if (info
->executable
)
1328 to_type
= R_X86_64_TPOFF32
;
1335 /* Return TRUE if there is no transition. */
1336 if (from_type
== to_type
)
1339 /* Check if the transition can be performed. */
1341 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1342 symtab_hdr
, sym_hashes
,
1343 from_type
, rel
, relend
))
1345 reloc_howto_type
*from
, *to
;
1348 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1349 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1352 name
= h
->root
.root
.string
;
1355 struct elf_x86_64_link_hash_table
*htab
;
1357 htab
= elf_x86_64_hash_table (info
);
1362 Elf_Internal_Sym
*isym
;
1364 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1366 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1370 (*_bfd_error_handler
)
1371 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1372 "in section `%A' failed"),
1373 abfd
, sec
, from
->name
, to
->name
, name
,
1374 (unsigned long) rel
->r_offset
);
1375 bfd_set_error (bfd_error_bad_value
);
1383 /* Look through the relocs for a section during the first phase, and
1384 calculate needed space in the global offset table, procedure
1385 linkage table, and dynamic reloc sections. */
1388 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1390 const Elf_Internal_Rela
*relocs
)
1392 struct elf_x86_64_link_hash_table
*htab
;
1393 Elf_Internal_Shdr
*symtab_hdr
;
1394 struct elf_link_hash_entry
**sym_hashes
;
1395 const Elf_Internal_Rela
*rel
;
1396 const Elf_Internal_Rela
*rel_end
;
1399 if (info
->relocatable
)
1402 BFD_ASSERT (is_x86_64_elf (abfd
));
1404 htab
= elf_x86_64_hash_table (info
);
1408 symtab_hdr
= &elf_symtab_hdr (abfd
);
1409 sym_hashes
= elf_sym_hashes (abfd
);
1413 rel_end
= relocs
+ sec
->reloc_count
;
1414 for (rel
= relocs
; rel
< rel_end
; rel
++)
1416 unsigned int r_type
;
1417 unsigned long r_symndx
;
1418 struct elf_link_hash_entry
*h
;
1419 Elf_Internal_Sym
*isym
;
1422 r_symndx
= htab
->r_sym (rel
->r_info
);
1423 r_type
= ELF32_R_TYPE (rel
->r_info
);
1425 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1427 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1432 if (r_symndx
< symtab_hdr
->sh_info
)
1434 /* A local symbol. */
1435 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1440 /* Check relocation against local STT_GNU_IFUNC symbol. */
1441 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1443 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1448 /* Fake a STT_GNU_IFUNC symbol. */
1449 h
->type
= STT_GNU_IFUNC
;
1452 h
->forced_local
= 1;
1453 h
->root
.type
= bfd_link_hash_defined
;
1461 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1462 while (h
->root
.type
== bfd_link_hash_indirect
1463 || h
->root
.type
== bfd_link_hash_warning
)
1464 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1467 /* Check invalid x32 relocations. */
1468 if (!ABI_64_P (abfd
))
1474 case R_X86_64_DTPOFF64
:
1475 case R_X86_64_TPOFF64
:
1477 case R_X86_64_GOTOFF64
:
1478 case R_X86_64_GOT64
:
1479 case R_X86_64_GOTPCREL64
:
1480 case R_X86_64_GOTPC64
:
1481 case R_X86_64_GOTPLT64
:
1482 case R_X86_64_PLTOFF64
:
1485 name
= h
->root
.root
.string
;
1487 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1489 (*_bfd_error_handler
)
1490 (_("%B: relocation %s against symbol `%s' isn't "
1491 "supported in x32 mode"), abfd
,
1492 x86_64_elf_howto_table
[r_type
].name
, name
);
1493 bfd_set_error (bfd_error_bad_value
);
1501 /* Create the ifunc sections for static executables. If we
1502 never see an indirect function symbol nor we are building
1503 a static executable, those sections will be empty and
1504 won't appear in output. */
1515 case R_X86_64_PLT32
:
1516 case R_X86_64_GOTPCREL
:
1517 case R_X86_64_GOTPCREL64
:
1518 if (htab
->elf
.dynobj
== NULL
)
1519 htab
->elf
.dynobj
= abfd
;
1520 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1525 /* It is referenced by a non-shared object. */
1529 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1530 symtab_hdr
, sym_hashes
,
1531 &r_type
, GOT_UNKNOWN
,
1532 rel
, rel_end
, h
, r_symndx
))
1537 case R_X86_64_TLSLD
:
1538 htab
->tls_ld_got
.refcount
+= 1;
1541 case R_X86_64_TPOFF32
:
1542 if (!info
->executable
&& ABI_64_P (abfd
))
1545 name
= h
->root
.root
.string
;
1547 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1549 (*_bfd_error_handler
)
1550 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1552 x86_64_elf_howto_table
[r_type
].name
, name
);
1553 bfd_set_error (bfd_error_bad_value
);
1558 case R_X86_64_GOTTPOFF
:
1559 if (!info
->executable
)
1560 info
->flags
|= DF_STATIC_TLS
;
1563 case R_X86_64_GOT32
:
1564 case R_X86_64_GOTPCREL
:
1565 case R_X86_64_TLSGD
:
1566 case R_X86_64_GOT64
:
1567 case R_X86_64_GOTPCREL64
:
1568 case R_X86_64_GOTPLT64
:
1569 case R_X86_64_GOTPC32_TLSDESC
:
1570 case R_X86_64_TLSDESC_CALL
:
1571 /* This symbol requires a global offset table entry. */
1573 int tls_type
, old_tls_type
;
1577 default: tls_type
= GOT_NORMAL
; break;
1578 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1579 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1580 case R_X86_64_GOTPC32_TLSDESC
:
1581 case R_X86_64_TLSDESC_CALL
:
1582 tls_type
= GOT_TLS_GDESC
; break;
1587 if (r_type
== R_X86_64_GOTPLT64
)
1589 /* This relocation indicates that we also need
1590 a PLT entry, as this is a function. We don't need
1591 a PLT entry for local symbols. */
1593 h
->plt
.refcount
+= 1;
1595 h
->got
.refcount
+= 1;
1596 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1600 bfd_signed_vma
*local_got_refcounts
;
1602 /* This is a global offset table entry for a local symbol. */
1603 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1604 if (local_got_refcounts
== NULL
)
1608 size
= symtab_hdr
->sh_info
;
1609 size
*= sizeof (bfd_signed_vma
)
1610 + sizeof (bfd_vma
) + sizeof (char);
1611 local_got_refcounts
= ((bfd_signed_vma
*)
1612 bfd_zalloc (abfd
, size
));
1613 if (local_got_refcounts
== NULL
)
1615 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1616 elf_x86_64_local_tlsdesc_gotent (abfd
)
1617 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1618 elf_x86_64_local_got_tls_type (abfd
)
1619 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1621 local_got_refcounts
[r_symndx
] += 1;
1623 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1626 /* If a TLS symbol is accessed using IE at least once,
1627 there is no point to use dynamic model for it. */
1628 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1629 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1630 || tls_type
!= GOT_TLS_IE
))
1632 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1633 tls_type
= old_tls_type
;
1634 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1635 && GOT_TLS_GD_ANY_P (tls_type
))
1636 tls_type
|= old_tls_type
;
1640 name
= h
->root
.root
.string
;
1642 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1644 (*_bfd_error_handler
)
1645 (_("%B: '%s' accessed both as normal and thread local symbol"),
1647 bfd_set_error (bfd_error_bad_value
);
1652 if (old_tls_type
!= tls_type
)
1655 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1657 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1662 case R_X86_64_GOTOFF64
:
1663 case R_X86_64_GOTPC32
:
1664 case R_X86_64_GOTPC64
:
1666 if (htab
->elf
.sgot
== NULL
)
1668 if (htab
->elf
.dynobj
== NULL
)
1669 htab
->elf
.dynobj
= abfd
;
1670 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1676 case R_X86_64_PLT32
:
1677 /* This symbol requires a procedure linkage table entry. We
1678 actually build the entry in adjust_dynamic_symbol,
1679 because this might be a case of linking PIC code which is
1680 never referenced by a dynamic object, in which case we
1681 don't need to generate a procedure linkage table entry
1684 /* If this is a local symbol, we resolve it directly without
1685 creating a procedure linkage table entry. */
1690 h
->plt
.refcount
+= 1;
1693 case R_X86_64_PLTOFF64
:
1694 /* This tries to form the 'address' of a function relative
1695 to GOT. For global symbols we need a PLT entry. */
1699 h
->plt
.refcount
+= 1;
1704 if (!ABI_64_P (abfd
))
1709 /* Let's help debug shared library creation. These relocs
1710 cannot be used in shared libs. Don't error out for
1711 sections we don't care about, such as debug sections or
1712 non-constant sections. */
1714 && (sec
->flags
& SEC_ALLOC
) != 0
1715 && (sec
->flags
& SEC_READONLY
) != 0)
1718 name
= h
->root
.root
.string
;
1720 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1721 (*_bfd_error_handler
)
1722 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1723 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1724 bfd_set_error (bfd_error_bad_value
);
1735 if (h
!= NULL
&& info
->executable
)
1737 /* If this reloc is in a read-only section, we might
1738 need a copy reloc. We can't check reliably at this
1739 stage whether the section is read-only, as input
1740 sections have not yet been mapped to output sections.
1741 Tentatively set the flag for now, and correct in
1742 adjust_dynamic_symbol. */
1745 /* We may need a .plt entry if the function this reloc
1746 refers to is in a shared lib. */
1747 h
->plt
.refcount
+= 1;
1748 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1749 h
->pointer_equality_needed
= 1;
1752 /* If we are creating a shared library, and this is a reloc
1753 against a global symbol, or a non PC relative reloc
1754 against a local symbol, then we need to copy the reloc
1755 into the shared library. However, if we are linking with
1756 -Bsymbolic, we do not need to copy a reloc against a
1757 global symbol which is defined in an object we are
1758 including in the link (i.e., DEF_REGULAR is set). At
1759 this point we have not seen all the input files, so it is
1760 possible that DEF_REGULAR is not set now but will be set
1761 later (it is never cleared). In case of a weak definition,
1762 DEF_REGULAR may be cleared later by a strong definition in
1763 a shared library. We account for that possibility below by
1764 storing information in the relocs_copied field of the hash
1765 table entry. A similar situation occurs when creating
1766 shared libraries and symbol visibility changes render the
1769 If on the other hand, we are creating an executable, we
1770 may need to keep relocations for symbols satisfied by a
1771 dynamic library if we manage to avoid copy relocs for the
1774 && (sec
->flags
& SEC_ALLOC
) != 0
1775 && (! IS_X86_64_PCREL_TYPE (r_type
)
1777 && (! SYMBOLIC_BIND (info
, h
)
1778 || h
->root
.type
== bfd_link_hash_defweak
1779 || !h
->def_regular
))))
1780 || (ELIMINATE_COPY_RELOCS
1782 && (sec
->flags
& SEC_ALLOC
) != 0
1784 && (h
->root
.type
== bfd_link_hash_defweak
1785 || !h
->def_regular
)))
1787 struct elf_dyn_relocs
*p
;
1788 struct elf_dyn_relocs
**head
;
1790 /* We must copy these reloc types into the output file.
1791 Create a reloc section in dynobj and make room for
1795 if (htab
->elf
.dynobj
== NULL
)
1796 htab
->elf
.dynobj
= abfd
;
1798 sreloc
= _bfd_elf_make_dynamic_reloc_section
1799 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1800 abfd
, /*rela?*/ TRUE
);
1806 /* If this is a global symbol, we count the number of
1807 relocations we need for this symbol. */
1810 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1814 /* Track dynamic relocs needed for local syms too.
1815 We really need local syms available to do this
1820 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1825 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1829 /* Beware of type punned pointers vs strict aliasing
1831 vpp
= &(elf_section_data (s
)->local_dynrel
);
1832 head
= (struct elf_dyn_relocs
**)vpp
;
1836 if (p
== NULL
|| p
->sec
!= sec
)
1838 bfd_size_type amt
= sizeof *p
;
1840 p
= ((struct elf_dyn_relocs
*)
1841 bfd_alloc (htab
->elf
.dynobj
, amt
));
1852 if (IS_X86_64_PCREL_TYPE (r_type
))
1857 /* This relocation describes the C++ object vtable hierarchy.
1858 Reconstruct it for later use during GC. */
1859 case R_X86_64_GNU_VTINHERIT
:
1860 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1864 /* This relocation describes which C++ vtable entries are actually
1865 used. Record for later use during GC. */
1866 case R_X86_64_GNU_VTENTRY
:
1867 BFD_ASSERT (h
!= NULL
);
1869 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1881 /* Return the section that should be marked against GC for a given
1885 elf_x86_64_gc_mark_hook (asection
*sec
,
1886 struct bfd_link_info
*info
,
1887 Elf_Internal_Rela
*rel
,
1888 struct elf_link_hash_entry
*h
,
1889 Elf_Internal_Sym
*sym
)
1892 switch (ELF32_R_TYPE (rel
->r_info
))
1894 case R_X86_64_GNU_VTINHERIT
:
1895 case R_X86_64_GNU_VTENTRY
:
1899 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1902 /* Update the got entry reference counts for the section being removed. */
1905 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1907 const Elf_Internal_Rela
*relocs
)
1909 struct elf_x86_64_link_hash_table
*htab
;
1910 Elf_Internal_Shdr
*symtab_hdr
;
1911 struct elf_link_hash_entry
**sym_hashes
;
1912 bfd_signed_vma
*local_got_refcounts
;
1913 const Elf_Internal_Rela
*rel
, *relend
;
1915 if (info
->relocatable
)
1918 htab
= elf_x86_64_hash_table (info
);
1922 elf_section_data (sec
)->local_dynrel
= NULL
;
1924 symtab_hdr
= &elf_symtab_hdr (abfd
);
1925 sym_hashes
= elf_sym_hashes (abfd
);
1926 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1928 htab
= elf_x86_64_hash_table (info
);
1929 relend
= relocs
+ sec
->reloc_count
;
1930 for (rel
= relocs
; rel
< relend
; rel
++)
1932 unsigned long r_symndx
;
1933 unsigned int r_type
;
1934 struct elf_link_hash_entry
*h
= NULL
;
1936 r_symndx
= htab
->r_sym (rel
->r_info
);
1937 if (r_symndx
>= symtab_hdr
->sh_info
)
1939 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1940 while (h
->root
.type
== bfd_link_hash_indirect
1941 || h
->root
.type
== bfd_link_hash_warning
)
1942 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1946 /* A local symbol. */
1947 Elf_Internal_Sym
*isym
;
1949 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1952 /* Check relocation against local STT_GNU_IFUNC symbol. */
1954 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1956 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1964 struct elf_x86_64_link_hash_entry
*eh
;
1965 struct elf_dyn_relocs
**pp
;
1966 struct elf_dyn_relocs
*p
;
1968 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1970 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1973 /* Everything must go for SEC. */
1979 r_type
= ELF32_R_TYPE (rel
->r_info
);
1980 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1981 symtab_hdr
, sym_hashes
,
1982 &r_type
, GOT_UNKNOWN
,
1983 rel
, relend
, h
, r_symndx
))
1988 case R_X86_64_TLSLD
:
1989 if (htab
->tls_ld_got
.refcount
> 0)
1990 htab
->tls_ld_got
.refcount
-= 1;
1993 case R_X86_64_TLSGD
:
1994 case R_X86_64_GOTPC32_TLSDESC
:
1995 case R_X86_64_TLSDESC_CALL
:
1996 case R_X86_64_GOTTPOFF
:
1997 case R_X86_64_GOT32
:
1998 case R_X86_64_GOTPCREL
:
1999 case R_X86_64_GOT64
:
2000 case R_X86_64_GOTPCREL64
:
2001 case R_X86_64_GOTPLT64
:
2004 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
2005 h
->plt
.refcount
-= 1;
2006 if (h
->got
.refcount
> 0)
2007 h
->got
.refcount
-= 1;
2008 if (h
->type
== STT_GNU_IFUNC
)
2010 if (h
->plt
.refcount
> 0)
2011 h
->plt
.refcount
-= 1;
2014 else if (local_got_refcounts
!= NULL
)
2016 if (local_got_refcounts
[r_symndx
] > 0)
2017 local_got_refcounts
[r_symndx
] -= 1;
2031 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2035 case R_X86_64_PLT32
:
2036 case R_X86_64_PLTOFF64
:
2039 if (h
->plt
.refcount
> 0)
2040 h
->plt
.refcount
-= 1;
2052 /* Adjust a symbol defined by a dynamic object and referenced by a
2053 regular object. The current definition is in some section of the
2054 dynamic object, but we're not including those sections. We have to
2055 change the definition to something the rest of the link can
2059 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2060 struct elf_link_hash_entry
*h
)
2062 struct elf_x86_64_link_hash_table
*htab
;
2064 struct elf_x86_64_link_hash_entry
*eh
;
2065 struct elf_dyn_relocs
*p
;
2067 /* STT_GNU_IFUNC symbol must go through PLT. */
2068 if (h
->type
== STT_GNU_IFUNC
)
2070 /* All local STT_GNU_IFUNC references must be treate as local
2071 calls via local PLT. */
2073 && SYMBOL_CALLS_LOCAL (info
, h
))
2075 bfd_size_type pc_count
= 0, count
= 0;
2076 struct elf_dyn_relocs
**pp
;
2078 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2079 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2081 pc_count
+= p
->pc_count
;
2082 p
->count
-= p
->pc_count
;
2091 if (pc_count
|| count
)
2095 if (h
->plt
.refcount
<= 0)
2096 h
->plt
.refcount
= 1;
2098 h
->plt
.refcount
+= 1;
2102 if (h
->plt
.refcount
<= 0)
2104 h
->plt
.offset
= (bfd_vma
) -1;
2110 /* If this is a function, put it in the procedure linkage table. We
2111 will fill in the contents of the procedure linkage table later,
2112 when we know the address of the .got section. */
2113 if (h
->type
== STT_FUNC
2116 if (h
->plt
.refcount
<= 0
2117 || SYMBOL_CALLS_LOCAL (info
, h
)
2118 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2119 && h
->root
.type
== bfd_link_hash_undefweak
))
2121 /* This case can occur if we saw a PLT32 reloc in an input
2122 file, but the symbol was never referred to by a dynamic
2123 object, or if all references were garbage collected. In
2124 such a case, we don't actually need to build a procedure
2125 linkage table, and we can just do a PC32 reloc instead. */
2126 h
->plt
.offset
= (bfd_vma
) -1;
2133 /* It's possible that we incorrectly decided a .plt reloc was
2134 needed for an R_X86_64_PC32 reloc to a non-function sym in
2135 check_relocs. We can't decide accurately between function and
2136 non-function syms in check-relocs; Objects loaded later in
2137 the link may change h->type. So fix it now. */
2138 h
->plt
.offset
= (bfd_vma
) -1;
2140 /* If this is a weak symbol, and there is a real definition, the
2141 processor independent code will have arranged for us to see the
2142 real definition first, and we can just use the same value. */
2143 if (h
->u
.weakdef
!= NULL
)
2145 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2146 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2147 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2148 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2149 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2150 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2154 /* This is a reference to a symbol defined by a dynamic object which
2155 is not a function. */
2157 /* If we are creating a shared library, we must presume that the
2158 only references to the symbol are via the global offset table.
2159 For such cases we need not do anything here; the relocations will
2160 be handled correctly by relocate_section. */
2164 /* If there are no references to this symbol that do not use the
2165 GOT, we don't need to generate a copy reloc. */
2166 if (!h
->non_got_ref
)
2169 /* If -z nocopyreloc was given, we won't generate them either. */
2170 if (info
->nocopyreloc
)
2176 if (ELIMINATE_COPY_RELOCS
)
2178 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2179 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2181 s
= p
->sec
->output_section
;
2182 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2186 /* If we didn't find any dynamic relocs in read-only sections, then
2187 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2195 /* We must allocate the symbol in our .dynbss section, which will
2196 become part of the .bss section of the executable. There will be
2197 an entry for this symbol in the .dynsym section. The dynamic
2198 object will contain position independent code, so all references
2199 from the dynamic object to this symbol will go through the global
2200 offset table. The dynamic linker will use the .dynsym entry to
2201 determine the address it must put in the global offset table, so
2202 both the dynamic object and the regular object will refer to the
2203 same memory location for the variable. */
2205 htab
= elf_x86_64_hash_table (info
);
2209 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2210 to copy the initial value out of the dynamic object and into the
2211 runtime process image. */
2212 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2214 const struct elf_backend_data
*bed
;
2215 bed
= get_elf_backend_data (info
->output_bfd
);
2216 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2222 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2225 /* Allocate space in .plt, .got and associated reloc sections for
2229 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2231 struct bfd_link_info
*info
;
2232 struct elf_x86_64_link_hash_table
*htab
;
2233 struct elf_x86_64_link_hash_entry
*eh
;
2234 struct elf_dyn_relocs
*p
;
2235 const struct elf_backend_data
*bed
;
2236 unsigned int plt_entry_size
;
2238 if (h
->root
.type
== bfd_link_hash_indirect
)
2241 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2243 info
= (struct bfd_link_info
*) inf
;
2244 htab
= elf_x86_64_hash_table (info
);
2247 bed
= get_elf_backend_data (info
->output_bfd
);
2248 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2250 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2251 here if it is defined and referenced in a non-shared object. */
2252 if (h
->type
== STT_GNU_IFUNC
2254 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2258 else if (htab
->elf
.dynamic_sections_created
2259 && h
->plt
.refcount
> 0)
2261 /* Make sure this symbol is output as a dynamic symbol.
2262 Undefined weak syms won't yet be marked as dynamic. */
2263 if (h
->dynindx
== -1
2264 && !h
->forced_local
)
2266 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2271 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2273 asection
*s
= htab
->elf
.splt
;
2275 /* If this is the first .plt entry, make room for the special
2278 s
->size
+= plt_entry_size
;
2280 h
->plt
.offset
= s
->size
;
2282 /* If this symbol is not defined in a regular file, and we are
2283 not generating a shared library, then set the symbol to this
2284 location in the .plt. This is required to make function
2285 pointers compare as equal between the normal executable and
2286 the shared library. */
2290 h
->root
.u
.def
.section
= s
;
2291 h
->root
.u
.def
.value
= h
->plt
.offset
;
2294 /* Make room for this entry. */
2295 s
->size
+= plt_entry_size
;
2297 /* We also need to make an entry in the .got.plt section, which
2298 will be placed in the .got section by the linker script. */
2299 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2301 /* We also need to make an entry in the .rela.plt section. */
2302 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2303 htab
->elf
.srelplt
->reloc_count
++;
2307 h
->plt
.offset
= (bfd_vma
) -1;
2313 h
->plt
.offset
= (bfd_vma
) -1;
2317 eh
->tlsdesc_got
= (bfd_vma
) -1;
2319 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2320 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2321 if (h
->got
.refcount
> 0
2324 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2326 h
->got
.offset
= (bfd_vma
) -1;
2328 else if (h
->got
.refcount
> 0)
2332 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2334 /* Make sure this symbol is output as a dynamic symbol.
2335 Undefined weak syms won't yet be marked as dynamic. */
2336 if (h
->dynindx
== -1
2337 && !h
->forced_local
)
2339 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2343 if (GOT_TLS_GDESC_P (tls_type
))
2345 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2346 - elf_x86_64_compute_jump_table_size (htab
);
2347 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2348 h
->got
.offset
= (bfd_vma
) -2;
2350 if (! GOT_TLS_GDESC_P (tls_type
)
2351 || GOT_TLS_GD_P (tls_type
))
2354 h
->got
.offset
= s
->size
;
2355 s
->size
+= GOT_ENTRY_SIZE
;
2356 if (GOT_TLS_GD_P (tls_type
))
2357 s
->size
+= GOT_ENTRY_SIZE
;
2359 dyn
= htab
->elf
.dynamic_sections_created
;
2360 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2362 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2363 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2364 || tls_type
== GOT_TLS_IE
)
2365 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2366 else if (GOT_TLS_GD_P (tls_type
))
2367 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2368 else if (! GOT_TLS_GDESC_P (tls_type
)
2369 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2370 || h
->root
.type
!= bfd_link_hash_undefweak
)
2372 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2373 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2374 if (GOT_TLS_GDESC_P (tls_type
))
2376 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2377 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2381 h
->got
.offset
= (bfd_vma
) -1;
2383 if (eh
->dyn_relocs
== NULL
)
2386 /* In the shared -Bsymbolic case, discard space allocated for
2387 dynamic pc-relative relocs against symbols which turn out to be
2388 defined in regular objects. For the normal shared case, discard
2389 space for pc-relative relocs that have become local due to symbol
2390 visibility changes. */
2394 /* Relocs that use pc_count are those that appear on a call
2395 insn, or certain REL relocs that can generated via assembly.
2396 We want calls to protected symbols to resolve directly to the
2397 function rather than going via the plt. If people want
2398 function pointer comparisons to work as expected then they
2399 should avoid writing weird assembly. */
2400 if (SYMBOL_CALLS_LOCAL (info
, h
))
2402 struct elf_dyn_relocs
**pp
;
2404 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2406 p
->count
-= p
->pc_count
;
2415 /* Also discard relocs on undefined weak syms with non-default
2417 if (eh
->dyn_relocs
!= NULL
2418 && h
->root
.type
== bfd_link_hash_undefweak
)
2420 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2421 eh
->dyn_relocs
= NULL
;
2423 /* Make sure undefined weak symbols are output as a dynamic
2425 else if (h
->dynindx
== -1
2426 && ! h
->forced_local
2427 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2432 else if (ELIMINATE_COPY_RELOCS
)
2434 /* For the non-shared case, discard space for relocs against
2435 symbols which turn out to need copy relocs or are not
2441 || (htab
->elf
.dynamic_sections_created
2442 && (h
->root
.type
== bfd_link_hash_undefweak
2443 || h
->root
.type
== bfd_link_hash_undefined
))))
2445 /* Make sure this symbol is output as a dynamic symbol.
2446 Undefined weak syms won't yet be marked as dynamic. */
2447 if (h
->dynindx
== -1
2448 && ! h
->forced_local
2449 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2452 /* If that succeeded, we know we'll be keeping all the
2454 if (h
->dynindx
!= -1)
2458 eh
->dyn_relocs
= NULL
;
2463 /* Finally, allocate space. */
2464 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2468 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2470 BFD_ASSERT (sreloc
!= NULL
);
2472 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2478 /* Allocate space in .plt, .got and associated reloc sections for
2479 local dynamic relocs. */
2482 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2484 struct elf_link_hash_entry
*h
2485 = (struct elf_link_hash_entry
*) *slot
;
2487 if (h
->type
!= STT_GNU_IFUNC
2491 || h
->root
.type
!= bfd_link_hash_defined
)
2494 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2497 /* Find any dynamic relocs that apply to read-only sections. */
2500 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2503 struct elf_x86_64_link_hash_entry
*eh
;
2504 struct elf_dyn_relocs
*p
;
2506 /* Skip local IFUNC symbols. */
2507 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2510 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2511 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2513 asection
*s
= p
->sec
->output_section
;
2515 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2517 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2519 info
->flags
|= DF_TEXTREL
;
2521 if (info
->warn_shared_textrel
&& info
->shared
)
2522 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2523 p
->sec
->owner
, h
->root
.root
.string
,
2526 /* Not an error, just cut short the traversal. */
2534 mov foo@GOTPCREL(%rip), %reg
2537 with the local symbol, foo. */
2540 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2541 struct bfd_link_info
*link_info
)
2543 Elf_Internal_Shdr
*symtab_hdr
;
2544 Elf_Internal_Rela
*internal_relocs
;
2545 Elf_Internal_Rela
*irel
, *irelend
;
2547 struct elf_x86_64_link_hash_table
*htab
;
2548 bfd_boolean changed_contents
;
2549 bfd_boolean changed_relocs
;
2550 bfd_signed_vma
*local_got_refcounts
;
2552 /* Don't even try to convert non-ELF outputs. */
2553 if (!is_elf_hash_table (link_info
->hash
))
2556 /* Nothing to do if there are no codes, no relocations or no output. */
2557 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2558 || sec
->reloc_count
== 0
2559 || discarded_section (sec
))
2562 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2564 /* Load the relocations for this section. */
2565 internal_relocs
= (_bfd_elf_link_read_relocs
2566 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2567 link_info
->keep_memory
));
2568 if (internal_relocs
== NULL
)
2571 htab
= elf_x86_64_hash_table (link_info
);
2572 changed_contents
= FALSE
;
2573 changed_relocs
= FALSE
;
2574 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2576 /* Get the section contents. */
2577 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2578 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2581 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2585 irelend
= internal_relocs
+ sec
->reloc_count
;
2586 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2588 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2589 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2591 struct elf_link_hash_entry
*h
;
2593 if (r_type
!= R_X86_64_GOTPCREL
)
2596 /* Get the symbol referred to by the reloc. */
2597 if (r_symndx
< symtab_hdr
->sh_info
)
2599 Elf_Internal_Sym
*isym
;
2601 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2604 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2605 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2606 && bfd_get_8 (input_bfd
,
2607 contents
+ irel
->r_offset
- 2) == 0x8b)
2609 bfd_put_8 (output_bfd
, 0x8d,
2610 contents
+ irel
->r_offset
- 2);
2611 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2612 if (local_got_refcounts
!= NULL
2613 && local_got_refcounts
[r_symndx
] > 0)
2614 local_got_refcounts
[r_symndx
] -= 1;
2615 changed_contents
= TRUE
;
2616 changed_relocs
= TRUE
;
2621 indx
= r_symndx
- symtab_hdr
->sh_info
;
2622 h
= elf_sym_hashes (abfd
)[indx
];
2623 BFD_ASSERT (h
!= NULL
);
2625 while (h
->root
.type
== bfd_link_hash_indirect
2626 || h
->root
.type
== bfd_link_hash_warning
)
2627 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2629 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2630 avoid optimizing _DYNAMIC since ld.so may use its link-time
2633 && h
->type
!= STT_GNU_IFUNC
2634 && h
!= htab
->elf
.hdynamic
2635 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2636 && bfd_get_8 (input_bfd
,
2637 contents
+ irel
->r_offset
- 2) == 0x8b)
2639 bfd_put_8 (output_bfd
, 0x8d,
2640 contents
+ irel
->r_offset
- 2);
2641 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2642 if (h
->got
.refcount
> 0)
2643 h
->got
.refcount
-= 1;
2644 changed_contents
= TRUE
;
2645 changed_relocs
= TRUE
;
2649 if (contents
!= NULL
2650 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2652 if (!changed_contents
&& !link_info
->keep_memory
)
2656 /* Cache the section contents for elf_link_input_bfd. */
2657 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2661 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2663 if (!changed_relocs
)
2664 free (internal_relocs
);
2666 elf_section_data (sec
)->relocs
= internal_relocs
;
2672 if (contents
!= NULL
2673 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2675 if (internal_relocs
!= NULL
2676 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2677 free (internal_relocs
);
2681 /* Set the sizes of the dynamic sections. */
2684 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2685 struct bfd_link_info
*info
)
2687 struct elf_x86_64_link_hash_table
*htab
;
2692 const struct elf_backend_data
*bed
;
2694 htab
= elf_x86_64_hash_table (info
);
2697 bed
= get_elf_backend_data (output_bfd
);
2699 dynobj
= htab
->elf
.dynobj
;
2703 if (htab
->elf
.dynamic_sections_created
)
2705 /* Set the contents of the .interp section to the interpreter. */
2706 if (info
->executable
)
2708 s
= bfd_get_linker_section (dynobj
, ".interp");
2711 s
->size
= htab
->dynamic_interpreter_size
;
2712 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2716 /* Set up .got offsets for local syms, and space for local dynamic
2718 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2720 bfd_signed_vma
*local_got
;
2721 bfd_signed_vma
*end_local_got
;
2722 char *local_tls_type
;
2723 bfd_vma
*local_tlsdesc_gotent
;
2724 bfd_size_type locsymcount
;
2725 Elf_Internal_Shdr
*symtab_hdr
;
2728 if (! is_x86_64_elf (ibfd
))
2731 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2733 struct elf_dyn_relocs
*p
;
2735 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2738 for (p
= (struct elf_dyn_relocs
*)
2739 (elf_section_data (s
)->local_dynrel
);
2743 if (!bfd_is_abs_section (p
->sec
)
2744 && bfd_is_abs_section (p
->sec
->output_section
))
2746 /* Input section has been discarded, either because
2747 it is a copy of a linkonce section or due to
2748 linker script /DISCARD/, so we'll be discarding
2751 else if (p
->count
!= 0)
2753 srel
= elf_section_data (p
->sec
)->sreloc
;
2754 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2755 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2756 && (info
->flags
& DF_TEXTREL
) == 0)
2758 info
->flags
|= DF_TEXTREL
;
2759 if (info
->warn_shared_textrel
&& info
->shared
)
2760 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2761 p
->sec
->owner
, p
->sec
);
2767 local_got
= elf_local_got_refcounts (ibfd
);
2771 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2772 locsymcount
= symtab_hdr
->sh_info
;
2773 end_local_got
= local_got
+ locsymcount
;
2774 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2775 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2777 srel
= htab
->elf
.srelgot
;
2778 for (; local_got
< end_local_got
;
2779 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2781 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2784 if (GOT_TLS_GDESC_P (*local_tls_type
))
2786 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2787 - elf_x86_64_compute_jump_table_size (htab
);
2788 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2789 *local_got
= (bfd_vma
) -2;
2791 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2792 || GOT_TLS_GD_P (*local_tls_type
))
2794 *local_got
= s
->size
;
2795 s
->size
+= GOT_ENTRY_SIZE
;
2796 if (GOT_TLS_GD_P (*local_tls_type
))
2797 s
->size
+= GOT_ENTRY_SIZE
;
2800 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2801 || *local_tls_type
== GOT_TLS_IE
)
2803 if (GOT_TLS_GDESC_P (*local_tls_type
))
2805 htab
->elf
.srelplt
->size
2806 += bed
->s
->sizeof_rela
;
2807 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2809 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2810 || GOT_TLS_GD_P (*local_tls_type
))
2811 srel
->size
+= bed
->s
->sizeof_rela
;
2815 *local_got
= (bfd_vma
) -1;
2819 if (htab
->tls_ld_got
.refcount
> 0)
2821 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2823 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2824 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2825 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2828 htab
->tls_ld_got
.offset
= -1;
2830 /* Allocate global sym .plt and .got entries, and space for global
2831 sym dynamic relocs. */
2832 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2835 /* Allocate .plt and .got entries, and space for local symbols. */
2836 htab_traverse (htab
->loc_hash_table
,
2837 elf_x86_64_allocate_local_dynrelocs
,
2840 /* For every jump slot reserved in the sgotplt, reloc_count is
2841 incremented. However, when we reserve space for TLS descriptors,
2842 it's not incremented, so in order to compute the space reserved
2843 for them, it suffices to multiply the reloc count by the jump
2846 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2847 so that R_X86_64_IRELATIVE entries come last. */
2848 if (htab
->elf
.srelplt
)
2850 htab
->sgotplt_jump_table_size
2851 = elf_x86_64_compute_jump_table_size (htab
);
2852 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
2854 else if (htab
->elf
.irelplt
)
2855 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
2857 if (htab
->tlsdesc_plt
)
2859 /* If we're not using lazy TLS relocations, don't generate the
2860 PLT and GOT entries they require. */
2861 if ((info
->flags
& DF_BIND_NOW
))
2862 htab
->tlsdesc_plt
= 0;
2865 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2866 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2867 /* Reserve room for the initial entry.
2868 FIXME: we could probably do away with it in this case. */
2869 if (htab
->elf
.splt
->size
== 0)
2870 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2871 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2872 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
2876 if (htab
->elf
.sgotplt
)
2878 /* Don't allocate .got.plt section if there are no GOT nor PLT
2879 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2880 if ((htab
->elf
.hgot
== NULL
2881 || !htab
->elf
.hgot
->ref_regular_nonweak
)
2882 && (htab
->elf
.sgotplt
->size
2883 == get_elf_backend_data (output_bfd
)->got_header_size
)
2884 && (htab
->elf
.splt
== NULL
2885 || htab
->elf
.splt
->size
== 0)
2886 && (htab
->elf
.sgot
== NULL
2887 || htab
->elf
.sgot
->size
== 0)
2888 && (htab
->elf
.iplt
== NULL
2889 || htab
->elf
.iplt
->size
== 0)
2890 && (htab
->elf
.igotplt
== NULL
2891 || htab
->elf
.igotplt
->size
== 0))
2892 htab
->elf
.sgotplt
->size
= 0;
2895 if (htab
->plt_eh_frame
!= NULL
2896 && htab
->elf
.splt
!= NULL
2897 && htab
->elf
.splt
->size
!= 0
2898 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
2899 && _bfd_elf_eh_frame_present (info
))
2901 const struct elf_x86_64_backend_data
*arch_data
2902 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
2903 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
2906 /* We now have determined the sizes of the various dynamic sections.
2907 Allocate memory for them. */
2909 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2911 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2914 if (s
== htab
->elf
.splt
2915 || s
== htab
->elf
.sgot
2916 || s
== htab
->elf
.sgotplt
2917 || s
== htab
->elf
.iplt
2918 || s
== htab
->elf
.igotplt
2919 || s
== htab
->plt_eh_frame
2920 || s
== htab
->sdynbss
)
2922 /* Strip this section if we don't need it; see the
2925 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2927 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2930 /* We use the reloc_count field as a counter if we need
2931 to copy relocs into the output file. */
2932 if (s
!= htab
->elf
.srelplt
)
2937 /* It's not one of our sections, so don't allocate space. */
2943 /* If we don't need this section, strip it from the
2944 output file. This is mostly to handle .rela.bss and
2945 .rela.plt. We must create both sections in
2946 create_dynamic_sections, because they must be created
2947 before the linker maps input sections to output
2948 sections. The linker does that before
2949 adjust_dynamic_symbol is called, and it is that
2950 function which decides whether anything needs to go
2951 into these sections. */
2953 s
->flags
|= SEC_EXCLUDE
;
2957 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2960 /* Allocate memory for the section contents. We use bfd_zalloc
2961 here in case unused entries are not reclaimed before the
2962 section's contents are written out. This should not happen,
2963 but this way if it does, we get a R_X86_64_NONE reloc instead
2965 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2966 if (s
->contents
== NULL
)
2970 if (htab
->plt_eh_frame
!= NULL
2971 && htab
->plt_eh_frame
->contents
!= NULL
)
2973 const struct elf_x86_64_backend_data
*arch_data
2974 = (const struct elf_x86_64_backend_data
*) bed
->arch_data
;
2976 memcpy (htab
->plt_eh_frame
->contents
,
2977 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
2978 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
2979 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
2982 if (htab
->elf
.dynamic_sections_created
)
2984 /* Add some entries to the .dynamic section. We fill in the
2985 values later, in elf_x86_64_finish_dynamic_sections, but we
2986 must add the entries now so that we get the correct size for
2987 the .dynamic section. The DT_DEBUG entry is filled in by the
2988 dynamic linker and used by the debugger. */
2989 #define add_dynamic_entry(TAG, VAL) \
2990 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2992 if (info
->executable
)
2994 if (!add_dynamic_entry (DT_DEBUG
, 0))
2998 if (htab
->elf
.splt
->size
!= 0)
3000 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3001 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3002 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3003 || !add_dynamic_entry (DT_JMPREL
, 0))
3006 if (htab
->tlsdesc_plt
3007 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3008 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3014 if (!add_dynamic_entry (DT_RELA
, 0)
3015 || !add_dynamic_entry (DT_RELASZ
, 0)
3016 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3019 /* If any dynamic relocs apply to a read-only section,
3020 then we need a DT_TEXTREL entry. */
3021 if ((info
->flags
& DF_TEXTREL
) == 0)
3022 elf_link_hash_traverse (&htab
->elf
,
3023 elf_x86_64_readonly_dynrelocs
,
3026 if ((info
->flags
& DF_TEXTREL
) != 0)
3028 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3033 #undef add_dynamic_entry
3039 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3040 struct bfd_link_info
*info
)
3042 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3046 struct elf_link_hash_entry
*tlsbase
;
3048 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3049 "_TLS_MODULE_BASE_",
3050 FALSE
, FALSE
, FALSE
);
3052 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3054 struct elf_x86_64_link_hash_table
*htab
;
3055 struct bfd_link_hash_entry
*bh
= NULL
;
3056 const struct elf_backend_data
*bed
3057 = get_elf_backend_data (output_bfd
);
3059 htab
= elf_x86_64_hash_table (info
);
3063 if (!(_bfd_generic_link_add_one_symbol
3064 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3065 tls_sec
, 0, NULL
, FALSE
,
3066 bed
->collect
, &bh
)))
3069 htab
->tls_module_base
= bh
;
3071 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3072 tlsbase
->def_regular
= 1;
3073 tlsbase
->other
= STV_HIDDEN
;
3074 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3081 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3082 executables. Rather than setting it to the beginning of the TLS
3083 section, we have to set it to the end. This function may be called
3084 multiple times, it is idempotent. */
3087 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3089 struct elf_x86_64_link_hash_table
*htab
;
3090 struct bfd_link_hash_entry
*base
;
3092 if (!info
->executable
)
3095 htab
= elf_x86_64_hash_table (info
);
3099 base
= htab
->tls_module_base
;
3103 base
->u
.def
.value
= htab
->elf
.tls_size
;
3106 /* Return the base VMA address which should be subtracted from real addresses
3107 when resolving @dtpoff relocation.
3108 This is PT_TLS segment p_vaddr. */
3111 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3113 /* If tls_sec is NULL, we should have signalled an error already. */
3114 if (elf_hash_table (info
)->tls_sec
== NULL
)
3116 return elf_hash_table (info
)->tls_sec
->vma
;
3119 /* Return the relocation value for @tpoff relocation
3120 if STT_TLS virtual address is ADDRESS. */
3123 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3125 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3126 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3127 bfd_vma static_tls_size
;
3129 /* If tls_segment is NULL, we should have signalled an error already. */
3130 if (htab
->tls_sec
== NULL
)
3133 /* Consider special static TLS alignment requirements. */
3134 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3135 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3138 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3142 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3144 /* Opcode Instruction
3147 0x0f 0x8x conditional jump */
3149 && (contents
[offset
- 1] == 0xe8
3150 || contents
[offset
- 1] == 0xe9))
3152 && contents
[offset
- 2] == 0x0f
3153 && (contents
[offset
- 1] & 0xf0) == 0x80));
3156 /* Relocate an x86_64 ELF section. */
3159 elf_x86_64_relocate_section (bfd
*output_bfd
,
3160 struct bfd_link_info
*info
,
3162 asection
*input_section
,
3164 Elf_Internal_Rela
*relocs
,
3165 Elf_Internal_Sym
*local_syms
,
3166 asection
**local_sections
)
3168 struct elf_x86_64_link_hash_table
*htab
;
3169 Elf_Internal_Shdr
*symtab_hdr
;
3170 struct elf_link_hash_entry
**sym_hashes
;
3171 bfd_vma
*local_got_offsets
;
3172 bfd_vma
*local_tlsdesc_gotents
;
3173 Elf_Internal_Rela
*rel
;
3174 Elf_Internal_Rela
*relend
;
3175 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3177 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3179 htab
= elf_x86_64_hash_table (info
);
3182 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3183 sym_hashes
= elf_sym_hashes (input_bfd
);
3184 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3185 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3187 elf_x86_64_set_tls_module_base (info
);
3190 relend
= relocs
+ input_section
->reloc_count
;
3191 for (; rel
< relend
; rel
++)
3193 unsigned int r_type
;
3194 reloc_howto_type
*howto
;
3195 unsigned long r_symndx
;
3196 struct elf_link_hash_entry
*h
;
3197 Elf_Internal_Sym
*sym
;
3199 bfd_vma off
, offplt
;
3201 bfd_boolean unresolved_reloc
;
3202 bfd_reloc_status_type r
;
3206 r_type
= ELF32_R_TYPE (rel
->r_info
);
3207 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3208 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3211 if (r_type
>= (int) R_X86_64_standard
)
3213 (*_bfd_error_handler
)
3214 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3215 input_bfd
, input_section
, r_type
);
3216 bfd_set_error (bfd_error_bad_value
);
3220 if (r_type
!= (int) R_X86_64_32
3221 || ABI_64_P (output_bfd
))
3222 howto
= x86_64_elf_howto_table
+ r_type
;
3224 howto
= (x86_64_elf_howto_table
3225 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3226 r_symndx
= htab
->r_sym (rel
->r_info
);
3230 unresolved_reloc
= FALSE
;
3231 if (r_symndx
< symtab_hdr
->sh_info
)
3233 sym
= local_syms
+ r_symndx
;
3234 sec
= local_sections
[r_symndx
];
3236 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3239 /* Relocate against local STT_GNU_IFUNC symbol. */
3240 if (!info
->relocatable
3241 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3243 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3248 /* Set STT_GNU_IFUNC symbol value. */
3249 h
->root
.u
.def
.value
= sym
->st_value
;
3250 h
->root
.u
.def
.section
= sec
;
3255 bfd_boolean warned ATTRIBUTE_UNUSED
;
3257 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3258 r_symndx
, symtab_hdr
, sym_hashes
,
3260 unresolved_reloc
, warned
);
3263 if (sec
!= NULL
&& discarded_section (sec
))
3264 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3265 rel
, 1, relend
, howto
, 0, contents
);
3267 if (info
->relocatable
)
3270 if (rel
->r_addend
== 0
3271 && r_type
== R_X86_64_64
3272 && !ABI_64_P (output_bfd
))
3274 /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3275 it to 64bit if addend is zero. */
3276 r_type
= R_X86_64_32
;
3277 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3280 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3281 it here if it is defined in a non-shared object. */
3283 && h
->type
== STT_GNU_IFUNC
3290 if ((input_section
->flags
& SEC_ALLOC
) == 0
3291 || h
->plt
.offset
== (bfd_vma
) -1)
3294 /* STT_GNU_IFUNC symbol must go through PLT. */
3295 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3296 relocation
= (plt
->output_section
->vma
3297 + plt
->output_offset
+ h
->plt
.offset
);
3302 if (h
->root
.root
.string
)
3303 name
= h
->root
.root
.string
;
3305 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3307 (*_bfd_error_handler
)
3308 (_("%B: relocation %s against STT_GNU_IFUNC "
3309 "symbol `%s' isn't handled by %s"), input_bfd
,
3310 x86_64_elf_howto_table
[r_type
].name
,
3311 name
, __FUNCTION__
);
3312 bfd_set_error (bfd_error_bad_value
);
3321 if (ABI_64_P (output_bfd
))
3325 if (rel
->r_addend
!= 0)
3327 if (h
->root
.root
.string
)
3328 name
= h
->root
.root
.string
;
3330 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3332 (*_bfd_error_handler
)
3333 (_("%B: relocation %s against STT_GNU_IFUNC "
3334 "symbol `%s' has non-zero addend: %d"),
3335 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3336 name
, rel
->r_addend
);
3337 bfd_set_error (bfd_error_bad_value
);
3341 /* Generate dynamic relcoation only when there is a
3342 non-GOT reference in a shared object. */
3343 if (info
->shared
&& h
->non_got_ref
)
3345 Elf_Internal_Rela outrel
;
3348 /* Need a dynamic relocation to get the real function
3350 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3354 if (outrel
.r_offset
== (bfd_vma
) -1
3355 || outrel
.r_offset
== (bfd_vma
) -2)
3358 outrel
.r_offset
+= (input_section
->output_section
->vma
3359 + input_section
->output_offset
);
3361 if (h
->dynindx
== -1
3363 || info
->executable
)
3365 /* This symbol is resolved locally. */
3366 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3367 outrel
.r_addend
= (h
->root
.u
.def
.value
3368 + h
->root
.u
.def
.section
->output_section
->vma
3369 + h
->root
.u
.def
.section
->output_offset
);
3373 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3374 outrel
.r_addend
= 0;
3377 sreloc
= htab
->elf
.irelifunc
;
3378 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3380 /* If this reloc is against an external symbol, we
3381 do not want to fiddle with the addend. Otherwise,
3382 we need to include the symbol value so that it
3383 becomes an addend for the dynamic reloc. For an
3384 internal symbol, we have updated addend. */
3390 case R_X86_64_PLT32
:
3393 case R_X86_64_GOTPCREL
:
3394 case R_X86_64_GOTPCREL64
:
3395 base_got
= htab
->elf
.sgot
;
3396 off
= h
->got
.offset
;
3398 if (base_got
== NULL
)
3401 if (off
== (bfd_vma
) -1)
3403 /* We can't use h->got.offset here to save state, or
3404 even just remember the offset, as finish_dynamic_symbol
3405 would use that as offset into .got. */
3407 if (htab
->elf
.splt
!= NULL
)
3409 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3410 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3411 base_got
= htab
->elf
.sgotplt
;
3415 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3416 off
= plt_index
* GOT_ENTRY_SIZE
;
3417 base_got
= htab
->elf
.igotplt
;
3420 if (h
->dynindx
== -1
3424 /* This references the local defitionion. We must
3425 initialize this entry in the global offset table.
3426 Since the offset must always be a multiple of 8,
3427 we use the least significant bit to record
3428 whether we have initialized it already.
3430 When doing a dynamic link, we create a .rela.got
3431 relocation entry to initialize the value. This
3432 is done in the finish_dynamic_symbol routine. */
3437 bfd_put_64 (output_bfd
, relocation
,
3438 base_got
->contents
+ off
);
3439 /* Note that this is harmless for the GOTPLT64
3440 case, as -1 | 1 still is -1. */
3446 relocation
= (base_got
->output_section
->vma
3447 + base_got
->output_offset
+ off
);
3453 /* When generating a shared object, the relocations handled here are
3454 copied into the output file to be resolved at run time. */
3457 case R_X86_64_GOT32
:
3458 case R_X86_64_GOT64
:
3459 /* Relocation is to the entry for this symbol in the global
3461 case R_X86_64_GOTPCREL
:
3462 case R_X86_64_GOTPCREL64
:
3463 /* Use global offset table entry as symbol value. */
3464 case R_X86_64_GOTPLT64
:
3465 /* This is the same as GOT64 for relocation purposes, but
3466 indicates the existence of a PLT entry. The difficulty is,
3467 that we must calculate the GOT slot offset from the PLT
3468 offset, if this symbol got a PLT entry (it was global).
3469 Additionally if it's computed from the PLT entry, then that
3470 GOT offset is relative to .got.plt, not to .got. */
3471 base_got
= htab
->elf
.sgot
;
3473 if (htab
->elf
.sgot
== NULL
)
3480 off
= h
->got
.offset
;
3482 && h
->plt
.offset
!= (bfd_vma
)-1
3483 && off
== (bfd_vma
)-1)
3485 /* We can't use h->got.offset here to save
3486 state, or even just remember the offset, as
3487 finish_dynamic_symbol would use that as offset into
3489 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3490 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3491 base_got
= htab
->elf
.sgotplt
;
3494 dyn
= htab
->elf
.dynamic_sections_created
;
3496 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3498 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3499 || (ELF_ST_VISIBILITY (h
->other
)
3500 && h
->root
.type
== bfd_link_hash_undefweak
))
3502 /* This is actually a static link, or it is a -Bsymbolic
3503 link and the symbol is defined locally, or the symbol
3504 was forced to be local because of a version file. We
3505 must initialize this entry in the global offset table.
3506 Since the offset must always be a multiple of 8, we
3507 use the least significant bit to record whether we
3508 have initialized it already.
3510 When doing a dynamic link, we create a .rela.got
3511 relocation entry to initialize the value. This is
3512 done in the finish_dynamic_symbol routine. */
3517 bfd_put_64 (output_bfd
, relocation
,
3518 base_got
->contents
+ off
);
3519 /* Note that this is harmless for the GOTPLT64 case,
3520 as -1 | 1 still is -1. */
3525 unresolved_reloc
= FALSE
;
3529 if (local_got_offsets
== NULL
)
3532 off
= local_got_offsets
[r_symndx
];
3534 /* The offset must always be a multiple of 8. We use
3535 the least significant bit to record whether we have
3536 already generated the necessary reloc. */
3541 bfd_put_64 (output_bfd
, relocation
,
3542 base_got
->contents
+ off
);
3547 Elf_Internal_Rela outrel
;
3549 /* We need to generate a R_X86_64_RELATIVE reloc
3550 for the dynamic linker. */
3551 s
= htab
->elf
.srelgot
;
3555 outrel
.r_offset
= (base_got
->output_section
->vma
3556 + base_got
->output_offset
3558 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3559 outrel
.r_addend
= relocation
;
3560 elf_append_rela (output_bfd
, s
, &outrel
);
3563 local_got_offsets
[r_symndx
] |= 1;
3567 if (off
>= (bfd_vma
) -2)
3570 relocation
= base_got
->output_section
->vma
3571 + base_got
->output_offset
+ off
;
3572 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3573 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3574 - htab
->elf
.sgotplt
->output_offset
;
3578 case R_X86_64_GOTOFF64
:
3579 /* Relocation is relative to the start of the global offset
3582 /* Check to make sure it isn't a protected function symbol
3583 for shared library since it may not be local when used
3584 as function address. */
3585 if (!info
->executable
3587 && !SYMBOLIC_BIND (info
, h
)
3589 && h
->type
== STT_FUNC
3590 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3592 (*_bfd_error_handler
)
3593 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3594 input_bfd
, h
->root
.root
.string
);
3595 bfd_set_error (bfd_error_bad_value
);
3599 /* Note that sgot is not involved in this
3600 calculation. We always want the start of .got.plt. If we
3601 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3602 permitted by the ABI, we might have to change this
3604 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3605 + htab
->elf
.sgotplt
->output_offset
;
3608 case R_X86_64_GOTPC32
:
3609 case R_X86_64_GOTPC64
:
3610 /* Use global offset table as symbol value. */
3611 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3612 + htab
->elf
.sgotplt
->output_offset
;
3613 unresolved_reloc
= FALSE
;
3616 case R_X86_64_PLTOFF64
:
3617 /* Relocation is PLT entry relative to GOT. For local
3618 symbols it's the symbol itself relative to GOT. */
3620 /* See PLT32 handling. */
3621 && h
->plt
.offset
!= (bfd_vma
) -1
3622 && htab
->elf
.splt
!= NULL
)
3624 relocation
= (htab
->elf
.splt
->output_section
->vma
3625 + htab
->elf
.splt
->output_offset
3627 unresolved_reloc
= FALSE
;
3630 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3631 + htab
->elf
.sgotplt
->output_offset
;
3634 case R_X86_64_PLT32
:
3635 /* Relocation is to the entry for this symbol in the
3636 procedure linkage table. */
3638 /* Resolve a PLT32 reloc against a local symbol directly,
3639 without using the procedure linkage table. */
3643 if (h
->plt
.offset
== (bfd_vma
) -1
3644 || htab
->elf
.splt
== NULL
)
3646 /* We didn't make a PLT entry for this symbol. This
3647 happens when statically linking PIC code, or when
3648 using -Bsymbolic. */
3652 relocation
= (htab
->elf
.splt
->output_section
->vma
3653 + htab
->elf
.splt
->output_offset
3655 unresolved_reloc
= FALSE
;
3662 && (input_section
->flags
& SEC_ALLOC
) != 0
3663 && (input_section
->flags
& SEC_READONLY
) != 0
3666 bfd_boolean fail
= FALSE
;
3668 = (r_type
== R_X86_64_PC32
3669 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3671 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3673 /* Symbol is referenced locally. Make sure it is
3674 defined locally or for a branch. */
3675 fail
= !h
->def_regular
&& !branch
;
3679 /* Symbol isn't referenced locally. We only allow
3680 branch to symbol with non-default visibility. */
3682 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3689 const char *pic
= "";
3691 switch (ELF_ST_VISIBILITY (h
->other
))
3694 v
= _("hidden symbol");
3697 v
= _("internal symbol");
3700 v
= _("protected symbol");
3704 pic
= _("; recompile with -fPIC");
3709 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3711 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3713 (*_bfd_error_handler
) (fmt
, input_bfd
,
3714 x86_64_elf_howto_table
[r_type
].name
,
3715 v
, h
->root
.root
.string
, pic
);
3716 bfd_set_error (bfd_error_bad_value
);
3727 /* FIXME: The ABI says the linker should make sure the value is
3728 the same when it's zeroextended to 64 bit. */
3730 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3735 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3736 || h
->root
.type
!= bfd_link_hash_undefweak
)
3737 && (! IS_X86_64_PCREL_TYPE (r_type
)
3738 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3739 || (ELIMINATE_COPY_RELOCS
3746 || h
->root
.type
== bfd_link_hash_undefweak
3747 || h
->root
.type
== bfd_link_hash_undefined
)))
3749 Elf_Internal_Rela outrel
;
3750 bfd_boolean skip
, relocate
;
3753 /* When generating a shared object, these relocations
3754 are copied into the output file to be resolved at run
3760 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3762 if (outrel
.r_offset
== (bfd_vma
) -1)
3764 else if (outrel
.r_offset
== (bfd_vma
) -2)
3765 skip
= TRUE
, relocate
= TRUE
;
3767 outrel
.r_offset
+= (input_section
->output_section
->vma
3768 + input_section
->output_offset
);
3771 memset (&outrel
, 0, sizeof outrel
);
3773 /* h->dynindx may be -1 if this symbol was marked to
3777 && (IS_X86_64_PCREL_TYPE (r_type
)
3779 || ! SYMBOLIC_BIND (info
, h
)
3780 || ! h
->def_regular
))
3782 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3783 outrel
.r_addend
= rel
->r_addend
;
3787 /* This symbol is local, or marked to become local. */
3788 if (r_type
== htab
->pointer_r_type
)
3791 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3792 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3794 else if (r_type
== R_X86_64_64
3795 && !ABI_64_P (output_bfd
))
3798 outrel
.r_info
= htab
->r_info (0,
3799 R_X86_64_RELATIVE64
);
3800 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3801 /* Check addend overflow. */
3802 if ((outrel
.r_addend
& 0x80000000)
3803 != (rel
->r_addend
& 0x80000000))
3806 int addend
= rel
->r_addend
;
3807 if (h
&& h
->root
.root
.string
)
3808 name
= h
->root
.root
.string
;
3810 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3813 (*_bfd_error_handler
)
3814 (_("%B: addend -0x%x in relocation %s against "
3815 "symbol `%s' at 0x%lx in section `%A' is "
3817 input_bfd
, input_section
, addend
,
3818 x86_64_elf_howto_table
[r_type
].name
,
3819 name
, (unsigned long) rel
->r_offset
);
3821 (*_bfd_error_handler
)
3822 (_("%B: addend 0x%x in relocation %s against "
3823 "symbol `%s' at 0x%lx in section `%A' is "
3825 input_bfd
, input_section
, addend
,
3826 x86_64_elf_howto_table
[r_type
].name
,
3827 name
, (unsigned long) rel
->r_offset
);
3828 bfd_set_error (bfd_error_bad_value
);
3836 if (bfd_is_abs_section (sec
))
3838 else if (sec
== NULL
|| sec
->owner
== NULL
)
3840 bfd_set_error (bfd_error_bad_value
);
3847 /* We are turning this relocation into one
3848 against a section symbol. It would be
3849 proper to subtract the symbol's value,
3850 osec->vma, from the emitted reloc addend,
3851 but ld.so expects buggy relocs. */
3852 osec
= sec
->output_section
;
3853 sindx
= elf_section_data (osec
)->dynindx
;
3856 asection
*oi
= htab
->elf
.text_index_section
;
3857 sindx
= elf_section_data (oi
)->dynindx
;
3859 BFD_ASSERT (sindx
!= 0);
3862 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3863 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3867 sreloc
= elf_section_data (input_section
)->sreloc
;
3869 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3871 r
= bfd_reloc_notsupported
;
3872 goto check_relocation_error
;
3875 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3877 /* If this reloc is against an external symbol, we do
3878 not want to fiddle with the addend. Otherwise, we
3879 need to include the symbol value so that it becomes
3880 an addend for the dynamic reloc. */
3887 case R_X86_64_TLSGD
:
3888 case R_X86_64_GOTPC32_TLSDESC
:
3889 case R_X86_64_TLSDESC_CALL
:
3890 case R_X86_64_GOTTPOFF
:
3891 tls_type
= GOT_UNKNOWN
;
3892 if (h
== NULL
&& local_got_offsets
)
3893 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3895 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3897 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3898 input_section
, contents
,
3899 symtab_hdr
, sym_hashes
,
3900 &r_type
, tls_type
, rel
,
3901 relend
, h
, r_symndx
))
3904 if (r_type
== R_X86_64_TPOFF32
)
3906 bfd_vma roff
= rel
->r_offset
;
3908 BFD_ASSERT (! unresolved_reloc
);
3910 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3912 /* GD->LE transition. For 64bit, change
3913 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3914 .word 0x6666; rex64; call __tls_get_addr
3917 leaq foo@tpoff(%rax), %rax
3919 leaq foo@tlsgd(%rip), %rdi
3920 .word 0x6666; rex64; call __tls_get_addr
3923 leaq foo@tpoff(%rax), %rax */
3924 if (ABI_64_P (output_bfd
))
3925 memcpy (contents
+ roff
- 4,
3926 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3929 memcpy (contents
+ roff
- 3,
3930 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3932 bfd_put_32 (output_bfd
,
3933 elf_x86_64_tpoff (info
, relocation
),
3934 contents
+ roff
+ 8);
3935 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3939 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3941 /* GDesc -> LE transition.
3942 It's originally something like:
3943 leaq x@tlsdesc(%rip), %rax
3946 movl $x@tpoff, %rax. */
3948 unsigned int val
, type
;
3950 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3951 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3952 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3953 contents
+ roff
- 3);
3954 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3955 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3956 contents
+ roff
- 1);
3957 bfd_put_32 (output_bfd
,
3958 elf_x86_64_tpoff (info
, relocation
),
3962 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3964 /* GDesc -> LE transition.
3969 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3970 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3973 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
3975 /* IE->LE transition:
3976 Originally it can be one of:
3977 movq foo@gottpoff(%rip), %reg
3978 addq foo@gottpoff(%rip), %reg
3981 leaq foo(%reg), %reg
3984 unsigned int val
, type
, reg
;
3986 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3987 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3988 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3994 bfd_put_8 (output_bfd
, 0x49,
3995 contents
+ roff
- 3);
3996 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3997 bfd_put_8 (output_bfd
, 0x41,
3998 contents
+ roff
- 3);
3999 bfd_put_8 (output_bfd
, 0xc7,
4000 contents
+ roff
- 2);
4001 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4002 contents
+ roff
- 1);
4006 /* addq -> addq - addressing with %rsp/%r12 is
4009 bfd_put_8 (output_bfd
, 0x49,
4010 contents
+ roff
- 3);
4011 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4012 bfd_put_8 (output_bfd
, 0x41,
4013 contents
+ roff
- 3);
4014 bfd_put_8 (output_bfd
, 0x81,
4015 contents
+ roff
- 2);
4016 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4017 contents
+ roff
- 1);
4023 bfd_put_8 (output_bfd
, 0x4d,
4024 contents
+ roff
- 3);
4025 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4026 bfd_put_8 (output_bfd
, 0x45,
4027 contents
+ roff
- 3);
4028 bfd_put_8 (output_bfd
, 0x8d,
4029 contents
+ roff
- 2);
4030 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4031 contents
+ roff
- 1);
4033 bfd_put_32 (output_bfd
,
4034 elf_x86_64_tpoff (info
, relocation
),
4042 if (htab
->elf
.sgot
== NULL
)
4047 off
= h
->got
.offset
;
4048 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4052 if (local_got_offsets
== NULL
)
4055 off
= local_got_offsets
[r_symndx
];
4056 offplt
= local_tlsdesc_gotents
[r_symndx
];
4063 Elf_Internal_Rela outrel
;
4067 if (htab
->elf
.srelgot
== NULL
)
4070 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4072 if (GOT_TLS_GDESC_P (tls_type
))
4074 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4075 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4076 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4077 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4078 + htab
->elf
.sgotplt
->output_offset
4080 + htab
->sgotplt_jump_table_size
);
4081 sreloc
= htab
->elf
.srelplt
;
4083 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4085 outrel
.r_addend
= 0;
4086 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4089 sreloc
= htab
->elf
.srelgot
;
4091 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4092 + htab
->elf
.sgot
->output_offset
+ off
);
4094 if (GOT_TLS_GD_P (tls_type
))
4095 dr_type
= R_X86_64_DTPMOD64
;
4096 else if (GOT_TLS_GDESC_P (tls_type
))
4099 dr_type
= R_X86_64_TPOFF64
;
4101 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4102 outrel
.r_addend
= 0;
4103 if ((dr_type
== R_X86_64_TPOFF64
4104 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4105 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4106 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4108 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4110 if (GOT_TLS_GD_P (tls_type
))
4114 BFD_ASSERT (! unresolved_reloc
);
4115 bfd_put_64 (output_bfd
,
4116 relocation
- elf_x86_64_dtpoff_base (info
),
4117 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4121 bfd_put_64 (output_bfd
, 0,
4122 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4123 outrel
.r_info
= htab
->r_info (indx
,
4125 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4126 elf_append_rela (output_bfd
, sreloc
,
4135 local_got_offsets
[r_symndx
] |= 1;
4138 if (off
>= (bfd_vma
) -2
4139 && ! GOT_TLS_GDESC_P (tls_type
))
4141 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4143 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4144 || r_type
== R_X86_64_TLSDESC_CALL
)
4145 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4146 + htab
->elf
.sgotplt
->output_offset
4147 + offplt
+ htab
->sgotplt_jump_table_size
;
4149 relocation
= htab
->elf
.sgot
->output_section
->vma
4150 + htab
->elf
.sgot
->output_offset
+ off
;
4151 unresolved_reloc
= FALSE
;
4155 bfd_vma roff
= rel
->r_offset
;
4157 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4159 /* GD->IE transition. For 64bit, change
4160 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4161 .word 0x6666; rex64; call __tls_get_addr@plt
4164 addq foo@gottpoff(%rip), %rax
4166 leaq foo@tlsgd(%rip), %rdi
4167 .word 0x6666; rex64; call __tls_get_addr@plt
4170 addq foo@gottpoff(%rip), %rax */
4171 if (ABI_64_P (output_bfd
))
4172 memcpy (contents
+ roff
- 4,
4173 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4176 memcpy (contents
+ roff
- 3,
4177 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4180 relocation
= (htab
->elf
.sgot
->output_section
->vma
4181 + htab
->elf
.sgot
->output_offset
+ off
4183 - input_section
->output_section
->vma
4184 - input_section
->output_offset
4186 bfd_put_32 (output_bfd
, relocation
,
4187 contents
+ roff
+ 8);
4188 /* Skip R_X86_64_PLT32. */
4192 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4194 /* GDesc -> IE transition.
4195 It's originally something like:
4196 leaq x@tlsdesc(%rip), %rax
4199 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4201 /* Now modify the instruction as appropriate. To
4202 turn a leaq into a movq in the form we use it, it
4203 suffices to change the second byte from 0x8d to
4205 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4207 bfd_put_32 (output_bfd
,
4208 htab
->elf
.sgot
->output_section
->vma
4209 + htab
->elf
.sgot
->output_offset
+ off
4211 - input_section
->output_section
->vma
4212 - input_section
->output_offset
4217 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4219 /* GDesc -> IE transition.
4226 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4227 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4235 case R_X86_64_TLSLD
:
4236 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4237 input_section
, contents
,
4238 symtab_hdr
, sym_hashes
,
4239 &r_type
, GOT_UNKNOWN
,
4240 rel
, relend
, h
, r_symndx
))
4243 if (r_type
!= R_X86_64_TLSLD
)
4245 /* LD->LE transition:
4246 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4247 For 64bit, we change it into:
4248 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4249 For 32bit, we change it into:
4250 nopl 0x0(%rax); movl %fs:0, %eax. */
4252 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4253 if (ABI_64_P (output_bfd
))
4254 memcpy (contents
+ rel
->r_offset
- 3,
4255 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4257 memcpy (contents
+ rel
->r_offset
- 3,
4258 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4259 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4264 if (htab
->elf
.sgot
== NULL
)
4267 off
= htab
->tls_ld_got
.offset
;
4272 Elf_Internal_Rela outrel
;
4274 if (htab
->elf
.srelgot
== NULL
)
4277 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4278 + htab
->elf
.sgot
->output_offset
+ off
);
4280 bfd_put_64 (output_bfd
, 0,
4281 htab
->elf
.sgot
->contents
+ off
);
4282 bfd_put_64 (output_bfd
, 0,
4283 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4284 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4285 outrel
.r_addend
= 0;
4286 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4288 htab
->tls_ld_got
.offset
|= 1;
4290 relocation
= htab
->elf
.sgot
->output_section
->vma
4291 + htab
->elf
.sgot
->output_offset
+ off
;
4292 unresolved_reloc
= FALSE
;
4295 case R_X86_64_DTPOFF32
:
4296 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4297 relocation
-= elf_x86_64_dtpoff_base (info
);
4299 relocation
= elf_x86_64_tpoff (info
, relocation
);
4302 case R_X86_64_TPOFF32
:
4303 case R_X86_64_TPOFF64
:
4304 BFD_ASSERT (info
->executable
);
4305 relocation
= elf_x86_64_tpoff (info
, relocation
);
4312 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4313 because such sections are not SEC_ALLOC and thus ld.so will
4314 not process them. */
4315 if (unresolved_reloc
4316 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4318 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4319 rel
->r_offset
) != (bfd_vma
) -1)
4321 (*_bfd_error_handler
)
4322 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4325 (long) rel
->r_offset
,
4327 h
->root
.root
.string
);
4332 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4333 contents
, rel
->r_offset
,
4334 relocation
, rel
->r_addend
);
4336 check_relocation_error
:
4337 if (r
!= bfd_reloc_ok
)
4342 name
= h
->root
.root
.string
;
4345 name
= bfd_elf_string_from_elf_section (input_bfd
,
4346 symtab_hdr
->sh_link
,
4351 name
= bfd_section_name (input_bfd
, sec
);
4354 if (r
== bfd_reloc_overflow
)
4356 if (! ((*info
->callbacks
->reloc_overflow
)
4357 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4358 (bfd_vma
) 0, input_bfd
, input_section
,
4364 (*_bfd_error_handler
)
4365 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4366 input_bfd
, input_section
,
4367 (long) rel
->r_offset
, name
, (int) r
);
4376 /* Finish up dynamic symbol handling. We set the contents of various
4377 dynamic sections here. */
4380 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4381 struct bfd_link_info
*info
,
4382 struct elf_link_hash_entry
*h
,
4383 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4385 struct elf_x86_64_link_hash_table
*htab
;
4386 const struct elf_x86_64_backend_data
*const abed
4387 = get_elf_x86_64_backend_data (output_bfd
);
4389 htab
= elf_x86_64_hash_table (info
);
4393 if (h
->plt
.offset
!= (bfd_vma
) -1)
4397 Elf_Internal_Rela rela
;
4399 asection
*plt
, *gotplt
, *relplt
;
4400 const struct elf_backend_data
*bed
;
4402 /* When building a static executable, use .iplt, .igot.plt and
4403 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4404 if (htab
->elf
.splt
!= NULL
)
4406 plt
= htab
->elf
.splt
;
4407 gotplt
= htab
->elf
.sgotplt
;
4408 relplt
= htab
->elf
.srelplt
;
4412 plt
= htab
->elf
.iplt
;
4413 gotplt
= htab
->elf
.igotplt
;
4414 relplt
= htab
->elf
.irelplt
;
4417 /* This symbol has an entry in the procedure linkage table. Set
4419 if ((h
->dynindx
== -1
4420 && !((h
->forced_local
|| info
->executable
)
4422 && h
->type
== STT_GNU_IFUNC
))
4428 /* Get the index in the procedure linkage table which
4429 corresponds to this symbol. This is the index of this symbol
4430 in all the symbols for which we are making plt entries. The
4431 first entry in the procedure linkage table is reserved.
4433 Get the offset into the .got table of the entry that
4434 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4435 bytes. The first three are reserved for the dynamic linker.
4437 For static executables, we don't reserve anything. */
4439 if (plt
== htab
->elf
.splt
)
4441 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4442 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4446 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4447 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4450 /* Fill in the entry in the procedure linkage table. */
4451 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4452 abed
->plt_entry_size
);
4454 /* Insert the relocation positions of the plt section. */
4456 /* Put offset the PC-relative instruction referring to the GOT entry,
4457 subtracting the size of that instruction. */
4458 bfd_put_32 (output_bfd
,
4459 (gotplt
->output_section
->vma
4460 + gotplt
->output_offset
4462 - plt
->output_section
->vma
4463 - plt
->output_offset
4465 - abed
->plt_got_insn_size
),
4466 plt
->contents
+ h
->plt
.offset
+ abed
->plt_got_offset
);
4468 /* Fill in the entry in the global offset table, initially this
4469 points to the second part of the PLT entry. */
4470 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4471 + plt
->output_offset
4472 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4473 gotplt
->contents
+ got_offset
);
4475 /* Fill in the entry in the .rela.plt section. */
4476 rela
.r_offset
= (gotplt
->output_section
->vma
4477 + gotplt
->output_offset
4479 if (h
->dynindx
== -1
4480 || ((info
->executable
4481 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4483 && h
->type
== STT_GNU_IFUNC
))
4485 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4486 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4487 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4488 rela
.r_addend
= (h
->root
.u
.def
.value
4489 + h
->root
.u
.def
.section
->output_section
->vma
4490 + h
->root
.u
.def
.section
->output_offset
);
4491 /* R_X86_64_IRELATIVE comes last. */
4492 plt_index
= htab
->next_irelative_index
--;
4496 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4498 plt_index
= htab
->next_jump_slot_index
++;
4501 /* Don't fill PLT entry for static executables. */
4502 if (plt
== htab
->elf
.splt
)
4504 /* Put relocation index. */
4505 bfd_put_32 (output_bfd
, plt_index
,
4506 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4507 /* Put offset for jmp .PLT0. */
4508 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ abed
->plt_plt_insn_end
),
4509 plt
->contents
+ h
->plt
.offset
+ abed
->plt_plt_offset
);
4512 bed
= get_elf_backend_data (output_bfd
);
4513 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4514 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4516 if (!h
->def_regular
)
4518 /* Mark the symbol as undefined, rather than as defined in
4519 the .plt section. Leave the value if there were any
4520 relocations where pointer equality matters (this is a clue
4521 for the dynamic linker, to make function pointer
4522 comparisons work between an application and shared
4523 library), otherwise set it to zero. If a function is only
4524 called from a binary, there is no need to slow down
4525 shared libraries because of that. */
4526 sym
->st_shndx
= SHN_UNDEF
;
4527 if (!h
->pointer_equality_needed
)
4532 if (h
->got
.offset
!= (bfd_vma
) -1
4533 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4534 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4536 Elf_Internal_Rela rela
;
4538 /* This symbol has an entry in the global offset table. Set it
4540 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4543 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4544 + htab
->elf
.sgot
->output_offset
4545 + (h
->got
.offset
&~ (bfd_vma
) 1));
4547 /* If this is a static link, or it is a -Bsymbolic link and the
4548 symbol is defined locally or was forced to be local because
4549 of a version file, we just want to emit a RELATIVE reloc.
4550 The entry in the global offset table will already have been
4551 initialized in the relocate_section function. */
4553 && h
->type
== STT_GNU_IFUNC
)
4557 /* Generate R_X86_64_GLOB_DAT. */
4564 if (!h
->pointer_equality_needed
)
4567 /* For non-shared object, we can't use .got.plt, which
4568 contains the real function addres if we need pointer
4569 equality. We load the GOT entry with the PLT entry. */
4570 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4571 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4572 + plt
->output_offset
4574 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4578 else if (info
->shared
4579 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4581 if (!h
->def_regular
)
4583 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4584 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4585 rela
.r_addend
= (h
->root
.u
.def
.value
4586 + h
->root
.u
.def
.section
->output_section
->vma
4587 + h
->root
.u
.def
.section
->output_offset
);
4591 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4593 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4594 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4595 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4599 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4604 Elf_Internal_Rela rela
;
4606 /* This symbol needs a copy reloc. Set it up. */
4608 if (h
->dynindx
== -1
4609 || (h
->root
.type
!= bfd_link_hash_defined
4610 && h
->root
.type
!= bfd_link_hash_defweak
)
4611 || htab
->srelbss
== NULL
)
4614 rela
.r_offset
= (h
->root
.u
.def
.value
4615 + h
->root
.u
.def
.section
->output_section
->vma
4616 + h
->root
.u
.def
.section
->output_offset
);
4617 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4619 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4625 /* Finish up local dynamic symbol handling. We set the contents of
4626 various dynamic sections here. */
4629 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4631 struct elf_link_hash_entry
*h
4632 = (struct elf_link_hash_entry
*) *slot
;
4633 struct bfd_link_info
*info
4634 = (struct bfd_link_info
*) inf
;
4636 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4640 /* Used to decide how to sort relocs in an optimal manner for the
4641 dynamic linker, before writing them out. */
4643 static enum elf_reloc_type_class
4644 elf_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
4646 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4648 case R_X86_64_RELATIVE
:
4649 case R_X86_64_RELATIVE64
:
4650 return reloc_class_relative
;
4651 case R_X86_64_JUMP_SLOT
:
4652 return reloc_class_plt
;
4654 return reloc_class_copy
;
4656 return reloc_class_normal
;
4660 /* Finish up the dynamic sections. */
4663 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4664 struct bfd_link_info
*info
)
4666 struct elf_x86_64_link_hash_table
*htab
;
4669 const struct elf_x86_64_backend_data
*const abed
4670 = get_elf_x86_64_backend_data (output_bfd
);
4672 htab
= elf_x86_64_hash_table (info
);
4676 dynobj
= htab
->elf
.dynobj
;
4677 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4679 if (htab
->elf
.dynamic_sections_created
)
4681 bfd_byte
*dyncon
, *dynconend
;
4682 const struct elf_backend_data
*bed
;
4683 bfd_size_type sizeof_dyn
;
4685 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4688 bed
= get_elf_backend_data (dynobj
);
4689 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4690 dyncon
= sdyn
->contents
;
4691 dynconend
= sdyn
->contents
+ sdyn
->size
;
4692 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4694 Elf_Internal_Dyn dyn
;
4697 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4705 s
= htab
->elf
.sgotplt
;
4706 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4710 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4714 s
= htab
->elf
.srelplt
->output_section
;
4715 dyn
.d_un
.d_val
= s
->size
;
4719 /* The procedure linkage table relocs (DT_JMPREL) should
4720 not be included in the overall relocs (DT_RELA).
4721 Therefore, we override the DT_RELASZ entry here to
4722 make it not include the JMPREL relocs. Since the
4723 linker script arranges for .rela.plt to follow all
4724 other relocation sections, we don't have to worry
4725 about changing the DT_RELA entry. */
4726 if (htab
->elf
.srelplt
!= NULL
)
4728 s
= htab
->elf
.srelplt
->output_section
;
4729 dyn
.d_un
.d_val
-= s
->size
;
4733 case DT_TLSDESC_PLT
:
4735 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4736 + htab
->tlsdesc_plt
;
4739 case DT_TLSDESC_GOT
:
4741 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4742 + htab
->tlsdesc_got
;
4746 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4749 /* Fill in the special first entry in the procedure linkage table. */
4750 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4752 /* Fill in the first entry in the procedure linkage table. */
4753 memcpy (htab
->elf
.splt
->contents
,
4754 abed
->plt0_entry
, abed
->plt_entry_size
);
4755 /* Add offset for pushq GOT+8(%rip), since the instruction
4756 uses 6 bytes subtract this value. */
4757 bfd_put_32 (output_bfd
,
4758 (htab
->elf
.sgotplt
->output_section
->vma
4759 + htab
->elf
.sgotplt
->output_offset
4761 - htab
->elf
.splt
->output_section
->vma
4762 - htab
->elf
.splt
->output_offset
4764 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
4765 /* Add offset for the PC-relative instruction accessing GOT+16,
4766 subtracting the offset to the end of that instruction. */
4767 bfd_put_32 (output_bfd
,
4768 (htab
->elf
.sgotplt
->output_section
->vma
4769 + htab
->elf
.sgotplt
->output_offset
4771 - htab
->elf
.splt
->output_section
->vma
4772 - htab
->elf
.splt
->output_offset
4773 - abed
->plt0_got2_insn_end
),
4774 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
4776 elf_section_data (htab
->elf
.splt
->output_section
)
4777 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
4779 if (htab
->tlsdesc_plt
)
4781 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4782 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4784 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4785 abed
->plt0_entry
, abed
->plt_entry_size
);
4787 /* Add offset for pushq GOT+8(%rip), since the
4788 instruction uses 6 bytes subtract this value. */
4789 bfd_put_32 (output_bfd
,
4790 (htab
->elf
.sgotplt
->output_section
->vma
4791 + htab
->elf
.sgotplt
->output_offset
4793 - htab
->elf
.splt
->output_section
->vma
4794 - htab
->elf
.splt
->output_offset
4797 htab
->elf
.splt
->contents
4798 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
4799 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4800 where TGD stands for htab->tlsdesc_got, subtracting the offset
4801 to the end of that instruction. */
4802 bfd_put_32 (output_bfd
,
4803 (htab
->elf
.sgot
->output_section
->vma
4804 + htab
->elf
.sgot
->output_offset
4806 - htab
->elf
.splt
->output_section
->vma
4807 - htab
->elf
.splt
->output_offset
4809 - abed
->plt0_got2_insn_end
),
4810 htab
->elf
.splt
->contents
4811 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
4816 if (htab
->elf
.sgotplt
)
4818 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4820 (*_bfd_error_handler
)
4821 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4825 /* Fill in the first three entries in the global offset table. */
4826 if (htab
->elf
.sgotplt
->size
> 0)
4828 /* Set the first entry in the global offset table to the address of
4829 the dynamic section. */
4831 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4833 bfd_put_64 (output_bfd
,
4834 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4835 htab
->elf
.sgotplt
->contents
);
4836 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4837 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4838 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4841 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4845 /* Adjust .eh_frame for .plt section. */
4846 if (htab
->plt_eh_frame
!= NULL
4847 && htab
->plt_eh_frame
->contents
!= NULL
)
4849 if (htab
->elf
.splt
!= NULL
4850 && htab
->elf
.splt
->size
!= 0
4851 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
4852 && htab
->elf
.splt
->output_section
!= NULL
4853 && htab
->plt_eh_frame
->output_section
!= NULL
)
4855 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
4856 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
4857 + htab
->plt_eh_frame
->output_offset
4858 + PLT_FDE_START_OFFSET
;
4859 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
4860 htab
->plt_eh_frame
->contents
4861 + PLT_FDE_START_OFFSET
);
4863 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4865 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
4867 htab
->plt_eh_frame
->contents
))
4872 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4873 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4876 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4877 htab_traverse (htab
->loc_hash_table
,
4878 elf_x86_64_finish_local_dynamic_symbol
,
4884 /* Return address for Ith PLT stub in section PLT, for relocation REL
4885 or (bfd_vma) -1 if it should not be included. */
4888 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4889 const arelent
*rel ATTRIBUTE_UNUSED
)
4891 return plt
->vma
+ (i
+ 1) * GET_PLT_ENTRY_SIZE (plt
->owner
);
4894 /* Handle an x86-64 specific section when reading an object file. This
4895 is called when elfcode.h finds a section with an unknown type. */
4898 elf_x86_64_section_from_shdr (bfd
*abfd
,
4899 Elf_Internal_Shdr
*hdr
,
4903 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4906 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4912 /* Hook called by the linker routine which adds symbols from an object
4913 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4917 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4918 struct bfd_link_info
*info
,
4919 Elf_Internal_Sym
*sym
,
4920 const char **namep ATTRIBUTE_UNUSED
,
4921 flagword
*flagsp ATTRIBUTE_UNUSED
,
4927 switch (sym
->st_shndx
)
4929 case SHN_X86_64_LCOMMON
:
4930 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4933 lcomm
= bfd_make_section_with_flags (abfd
,
4937 | SEC_LINKER_CREATED
));
4940 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
4943 *valp
= sym
->st_size
;
4947 if ((abfd
->flags
& DYNAMIC
) == 0
4948 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
4949 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
4950 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
4956 /* Given a BFD section, try to locate the corresponding ELF section
4960 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4961 asection
*sec
, int *index_return
)
4963 if (sec
== &_bfd_elf_large_com_section
)
4965 *index_return
= SHN_X86_64_LCOMMON
;
4971 /* Process a symbol. */
4974 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4977 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4979 switch (elfsym
->internal_elf_sym
.st_shndx
)
4981 case SHN_X86_64_LCOMMON
:
4982 asym
->section
= &_bfd_elf_large_com_section
;
4983 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4984 /* Common symbol doesn't set BSF_GLOBAL. */
4985 asym
->flags
&= ~BSF_GLOBAL
;
4991 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
4993 return (sym
->st_shndx
== SHN_COMMON
4994 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
4998 elf_x86_64_common_section_index (asection
*sec
)
5000 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5003 return SHN_X86_64_LCOMMON
;
5007 elf_x86_64_common_section (asection
*sec
)
5009 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5010 return bfd_com_section_ptr
;
5012 return &_bfd_elf_large_com_section
;
5016 elf_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5017 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
5018 struct elf_link_hash_entry
*h
,
5019 Elf_Internal_Sym
*sym
,
5021 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
5022 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
5023 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
5024 bfd_boolean
*override ATTRIBUTE_UNUSED
,
5025 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
5026 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
5027 bfd_boolean
*newdyn ATTRIBUTE_UNUSED
,
5028 bfd_boolean
*newdef
,
5029 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
5030 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
5031 bfd
*abfd ATTRIBUTE_UNUSED
,
5033 bfd_boolean
*olddyn ATTRIBUTE_UNUSED
,
5034 bfd_boolean
*olddef
,
5035 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
5036 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
5040 /* A normal common symbol and a large common symbol result in a
5041 normal common symbol. We turn the large common symbol into a
5044 && h
->root
.type
== bfd_link_hash_common
5046 && bfd_is_com_section (*sec
)
5049 if (sym
->st_shndx
== SHN_COMMON
5050 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
5052 h
->root
.u
.c
.p
->section
5053 = bfd_make_section_old_way (oldbfd
, "COMMON");
5054 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5056 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5057 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) == 0)
5058 *psec
= *sec
= bfd_com_section_ptr
;
5065 elf_x86_64_additional_program_headers (bfd
*abfd
,
5066 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5071 /* Check to see if we need a large readonly segment. */
5072 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5073 if (s
&& (s
->flags
& SEC_LOAD
))
5076 /* Check to see if we need a large data segment. Since .lbss sections
5077 is placed right after the .bss section, there should be no need for
5078 a large data segment just because of .lbss. */
5079 s
= bfd_get_section_by_name (abfd
, ".ldata");
5080 if (s
&& (s
->flags
& SEC_LOAD
))
5086 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5089 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5091 if (h
->plt
.offset
!= (bfd_vma
) -1
5093 && !h
->pointer_equality_needed
)
5096 return _bfd_elf_hash_symbol (h
);
5099 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5102 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5103 const bfd_target
*output
)
5105 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5106 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5107 && _bfd_elf_relocs_compatible (input
, output
));
5110 static const struct bfd_elf_special_section
5111 elf_x86_64_special_sections
[]=
5113 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5114 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5115 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5116 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5117 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5118 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5119 { NULL
, 0, 0, 0, 0 }
5122 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5123 #define TARGET_LITTLE_NAME "elf64-x86-64"
5124 #define ELF_ARCH bfd_arch_i386
5125 #define ELF_TARGET_ID X86_64_ELF_DATA
5126 #define ELF_MACHINE_CODE EM_X86_64
5127 #define ELF_MAXPAGESIZE 0x200000
5128 #define ELF_MINPAGESIZE 0x1000
5129 #define ELF_COMMONPAGESIZE 0x1000
5131 #define elf_backend_can_gc_sections 1
5132 #define elf_backend_can_refcount 1
5133 #define elf_backend_want_got_plt 1
5134 #define elf_backend_plt_readonly 1
5135 #define elf_backend_want_plt_sym 0
5136 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5137 #define elf_backend_rela_normal 1
5138 #define elf_backend_plt_alignment 4
5140 #define elf_info_to_howto elf_x86_64_info_to_howto
5142 #define bfd_elf64_bfd_link_hash_table_create \
5143 elf_x86_64_link_hash_table_create
5144 #define bfd_elf64_bfd_link_hash_table_free \
5145 elf_x86_64_link_hash_table_free
5146 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5147 #define bfd_elf64_bfd_reloc_name_lookup \
5148 elf_x86_64_reloc_name_lookup
5150 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5151 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5152 #define elf_backend_check_relocs elf_x86_64_check_relocs
5153 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5154 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5155 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5156 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5157 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5158 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5159 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5160 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5162 #define elf_backend_write_core_note elf_x86_64_write_core_note
5164 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5165 #define elf_backend_relocate_section elf_x86_64_relocate_section
5166 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5167 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5168 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5169 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5170 #define elf_backend_object_p elf64_x86_64_elf_object_p
5171 #define bfd_elf64_mkobject elf_x86_64_mkobject
5173 #define elf_backend_section_from_shdr \
5174 elf_x86_64_section_from_shdr
5176 #define elf_backend_section_from_bfd_section \
5177 elf_x86_64_elf_section_from_bfd_section
5178 #define elf_backend_add_symbol_hook \
5179 elf_x86_64_add_symbol_hook
5180 #define elf_backend_symbol_processing \
5181 elf_x86_64_symbol_processing
5182 #define elf_backend_common_section_index \
5183 elf_x86_64_common_section_index
5184 #define elf_backend_common_section \
5185 elf_x86_64_common_section
5186 #define elf_backend_common_definition \
5187 elf_x86_64_common_definition
5188 #define elf_backend_merge_symbol \
5189 elf_x86_64_merge_symbol
5190 #define elf_backend_special_sections \
5191 elf_x86_64_special_sections
5192 #define elf_backend_additional_program_headers \
5193 elf_x86_64_additional_program_headers
5194 #define elf_backend_hash_symbol \
5195 elf_x86_64_hash_symbol
5197 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5199 #include "elf64-target.h"
5201 /* FreeBSD support. */
5203 #undef TARGET_LITTLE_SYM
5204 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5205 #undef TARGET_LITTLE_NAME
5206 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5209 #define ELF_OSABI ELFOSABI_FREEBSD
5212 #define elf64_bed elf64_x86_64_fbsd_bed
5214 #include "elf64-target.h"
5216 /* Solaris 2 support. */
5218 #undef TARGET_LITTLE_SYM
5219 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5220 #undef TARGET_LITTLE_NAME
5221 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5223 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5224 objects won't be recognized. */
5228 #define elf64_bed elf64_x86_64_sol2_bed
5230 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5232 #undef elf_backend_static_tls_alignment
5233 #define elf_backend_static_tls_alignment 16
5235 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5237 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5239 #undef elf_backend_want_plt_sym
5240 #define elf_backend_want_plt_sym 1
5242 #include "elf64-target.h"
5244 /* Native Client support. */
5246 #undef TARGET_LITTLE_SYM
5247 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5248 #undef TARGET_LITTLE_NAME
5249 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5251 #define elf64_bed elf64_x86_64_nacl_bed
5253 #undef ELF_MAXPAGESIZE
5254 #undef ELF_MINPAGESIZE
5255 #undef ELF_COMMONPAGESIZE
5256 #define ELF_MAXPAGESIZE 0x10000
5257 #define ELF_MINPAGESIZE 0x10000
5258 #define ELF_COMMONPAGESIZE 0x10000
5260 /* Restore defaults. */
5262 #undef elf_backend_static_tls_alignment
5263 #undef elf_backend_want_plt_sym
5264 #define elf_backend_want_plt_sym 0
5266 /* NaCl uses substantially different PLT entries for the same effects. */
5268 #undef elf_backend_plt_alignment
5269 #define elf_backend_plt_alignment 5
5270 #define NACL_PLT_ENTRY_SIZE 64
5271 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5273 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5275 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5276 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5277 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5278 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5279 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5281 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5282 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5284 /* 32 bytes of nop to pad out to the standard size. */
5285 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5286 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5287 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5288 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5289 0x66, /* excess data32 prefix */
5293 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5295 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5296 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5297 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5298 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5300 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5301 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5302 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5304 /* Lazy GOT entries point here (32-byte aligned). */
5305 0x68, /* pushq immediate */
5306 0, 0, 0, 0, /* replaced with index into relocation table. */
5307 0xe9, /* jmp relative */
5308 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5310 /* 22 bytes of nop to pad out to the standard size. */
5311 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5312 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5313 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5316 /* .eh_frame covering the .plt section. */
5318 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5320 #if (PLT_CIE_LENGTH != 20 \
5321 || PLT_FDE_LENGTH != 36 \
5322 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5323 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5324 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5326 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5327 0, 0, 0, 0, /* CIE ID */
5328 1, /* CIE version */
5329 'z', 'R', 0, /* Augmentation string */
5330 1, /* Code alignment factor */
5331 0x78, /* Data alignment factor */
5332 16, /* Return address column */
5333 1, /* Augmentation size */
5334 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5335 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5336 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5337 DW_CFA_nop
, DW_CFA_nop
,
5339 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5340 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5341 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5342 0, 0, 0, 0, /* .plt size goes here */
5343 0, /* Augmentation size */
5344 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5345 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5346 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5347 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5348 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5349 13, /* Block length */
5350 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5351 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5352 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5353 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5354 DW_CFA_nop
, DW_CFA_nop
5357 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5359 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5360 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5361 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5362 2, /* plt0_got1_offset */
5363 9, /* plt0_got2_offset */
5364 13, /* plt0_got2_insn_end */
5365 3, /* plt_got_offset */
5366 33, /* plt_reloc_offset */
5367 38, /* plt_plt_offset */
5368 7, /* plt_got_insn_size */
5369 42, /* plt_plt_insn_end */
5370 32, /* plt_lazy_offset */
5371 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5372 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5375 #undef elf_backend_arch_data
5376 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5378 #undef elf_backend_modify_segment_map
5379 #define elf_backend_modify_segment_map nacl_modify_segment_map
5380 #undef elf_backend_modify_program_headers
5381 #define elf_backend_modify_program_headers nacl_modify_program_headers
5383 #include "elf64-target.h"
5385 /* Native Client x32 support. */
5387 #undef TARGET_LITTLE_SYM
5388 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5389 #undef TARGET_LITTLE_NAME
5390 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5392 #define elf32_bed elf32_x86_64_nacl_bed
5394 #define bfd_elf32_bfd_link_hash_table_create \
5395 elf_x86_64_link_hash_table_create
5396 #define bfd_elf32_bfd_link_hash_table_free \
5397 elf_x86_64_link_hash_table_free
5398 #define bfd_elf32_bfd_reloc_type_lookup \
5399 elf_x86_64_reloc_type_lookup
5400 #define bfd_elf32_bfd_reloc_name_lookup \
5401 elf_x86_64_reloc_name_lookup
5402 #define bfd_elf32_mkobject \
5405 #undef elf_backend_object_p
5406 #define elf_backend_object_p \
5407 elf32_x86_64_elf_object_p
5409 #undef elf_backend_bfd_from_remote_memory
5410 #define elf_backend_bfd_from_remote_memory \
5411 _bfd_elf32_bfd_from_remote_memory
5413 #undef elf_backend_size_info
5414 #define elf_backend_size_info \
5415 _bfd_elf32_size_info
5417 #include "elf32-target.h"
5419 /* Restore defaults. */
5420 #undef elf_backend_object_p
5421 #define elf_backend_object_p elf64_x86_64_elf_object_p
5422 #undef elf_backend_bfd_from_remote_memory
5423 #undef elf_backend_size_info
5424 #undef elf_backend_modify_segment_map
5425 #undef elf_backend_modify_program_headers
5427 /* Intel L1OM support. */
5430 elf64_l1om_elf_object_p (bfd
*abfd
)
5432 /* Set the right machine number for an L1OM elf64 file. */
5433 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
5437 #undef TARGET_LITTLE_SYM
5438 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5439 #undef TARGET_LITTLE_NAME
5440 #define TARGET_LITTLE_NAME "elf64-l1om"
5442 #define ELF_ARCH bfd_arch_l1om
5444 #undef ELF_MACHINE_CODE
5445 #define ELF_MACHINE_CODE EM_L1OM
5450 #define elf64_bed elf64_l1om_bed
5452 #undef elf_backend_object_p
5453 #define elf_backend_object_p elf64_l1om_elf_object_p
5455 /* Restore defaults. */
5456 #undef ELF_MAXPAGESIZE
5457 #undef ELF_MINPAGESIZE
5458 #undef ELF_COMMONPAGESIZE
5459 #define ELF_MAXPAGESIZE 0x200000
5460 #define ELF_MINPAGESIZE 0x1000
5461 #define ELF_COMMONPAGESIZE 0x1000
5462 #undef elf_backend_plt_alignment
5463 #define elf_backend_plt_alignment 4
5464 #undef elf_backend_arch_data
5465 #define elf_backend_arch_data &elf_x86_64_arch_bed
5467 #include "elf64-target.h"
5469 /* FreeBSD L1OM support. */
5471 #undef TARGET_LITTLE_SYM
5472 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5473 #undef TARGET_LITTLE_NAME
5474 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5477 #define ELF_OSABI ELFOSABI_FREEBSD
5480 #define elf64_bed elf64_l1om_fbsd_bed
5482 #include "elf64-target.h"
5484 /* Intel K1OM support. */
5487 elf64_k1om_elf_object_p (bfd
*abfd
)
5489 /* Set the right machine number for an K1OM elf64 file. */
5490 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
5494 #undef TARGET_LITTLE_SYM
5495 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5496 #undef TARGET_LITTLE_NAME
5497 #define TARGET_LITTLE_NAME "elf64-k1om"
5499 #define ELF_ARCH bfd_arch_k1om
5501 #undef ELF_MACHINE_CODE
5502 #define ELF_MACHINE_CODE EM_K1OM
5507 #define elf64_bed elf64_k1om_bed
5509 #undef elf_backend_object_p
5510 #define elf_backend_object_p elf64_k1om_elf_object_p
5512 #undef elf_backend_static_tls_alignment
5514 #undef elf_backend_want_plt_sym
5515 #define elf_backend_want_plt_sym 0
5517 #include "elf64-target.h"
5519 /* FreeBSD K1OM support. */
5521 #undef TARGET_LITTLE_SYM
5522 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5523 #undef TARGET_LITTLE_NAME
5524 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5527 #define ELF_OSABI ELFOSABI_FREEBSD
5530 #define elf64_bed elf64_k1om_fbsd_bed
5532 #include "elf64-target.h"
5534 /* 32bit x86-64 support. */
5536 #undef TARGET_LITTLE_SYM
5537 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5538 #undef TARGET_LITTLE_NAME
5539 #define TARGET_LITTLE_NAME "elf32-x86-64"
5543 #define ELF_ARCH bfd_arch_i386
5545 #undef ELF_MACHINE_CODE
5546 #define ELF_MACHINE_CODE EM_X86_64
5550 #undef elf_backend_object_p
5551 #define elf_backend_object_p \
5552 elf32_x86_64_elf_object_p
5554 #undef elf_backend_bfd_from_remote_memory
5555 #define elf_backend_bfd_from_remote_memory \
5556 _bfd_elf32_bfd_from_remote_memory
5558 #undef elf_backend_size_info
5559 #define elf_backend_size_info \
5560 _bfd_elf32_size_info
5562 #include "elf32-target.h"