1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2015 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "elf/x86-64.h"
41 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
42 #define MINUS_ONE (~ (bfd_vma) 0)
44 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
45 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
46 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
47 since they are the same. */
49 #define ABI_64_P(abfd) \
50 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52 /* The relocation "howto" table. Order of fields:
53 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
54 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
55 static reloc_howto_type x86_64_elf_howto_table
[] =
57 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
58 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
60 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
63 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
64 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
67 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
69 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
70 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
73 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
75 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
76 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
78 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
79 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
81 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
82 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
84 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
85 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
87 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
88 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
90 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
91 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
93 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
94 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
95 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
97 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
99 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
100 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
101 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
104 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
107 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
110 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
113 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
114 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
116 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
117 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
119 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
120 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
122 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
123 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
125 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
126 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
128 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
129 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
130 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
131 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
132 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
133 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
134 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
135 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
137 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
140 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
141 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
142 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
143 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
144 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
146 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
147 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
149 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
150 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
152 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
153 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
155 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
156 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
157 "R_X86_64_GOTPC32_TLSDESC",
158 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
159 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
160 complain_overflow_dont
, bfd_elf_generic_reloc
,
161 "R_X86_64_TLSDESC_CALL",
163 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
164 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
166 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
167 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
170 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
171 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
173 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
174 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
176 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
177 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 /* We have a gap in the reloc numbers here.
181 R_X86_64_standard counts the number up to this point, and
182 R_X86_64_vt_offset is the value to subtract from a reloc type of
183 R_X86_64_GNU_VT* to form an index into this table. */
184 #define R_X86_64_standard (R_X86_64_PLT32_BND + 1)
185 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
187 /* GNU extension to record C++ vtable hierarchy. */
188 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
189 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
191 /* GNU extension to record C++ vtable member usage. */
192 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
193 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
196 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
197 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
198 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
202 #define IS_X86_64_PCREL_TYPE(TYPE) \
203 ( ((TYPE) == R_X86_64_PC8) \
204 || ((TYPE) == R_X86_64_PC16) \
205 || ((TYPE) == R_X86_64_PC32) \
206 || ((TYPE) == R_X86_64_PC32_BND) \
207 || ((TYPE) == R_X86_64_PC64))
209 /* Map BFD relocs to the x86_64 elf relocs. */
212 bfd_reloc_code_real_type bfd_reloc_val
;
213 unsigned char elf_reloc_val
;
216 static const struct elf_reloc_map x86_64_reloc_map
[] =
218 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
219 { BFD_RELOC_64
, R_X86_64_64
, },
220 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
221 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
222 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
223 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
224 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
225 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
226 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
227 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
228 { BFD_RELOC_32
, R_X86_64_32
, },
229 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
230 { BFD_RELOC_16
, R_X86_64_16
, },
231 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
232 { BFD_RELOC_8
, R_X86_64_8
, },
233 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
234 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
235 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
236 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
237 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
238 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
239 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
240 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
241 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
242 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
243 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
244 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
245 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
246 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
247 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
248 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
249 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
250 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
251 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
252 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
253 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
254 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
255 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
256 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
,},
257 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
,},
258 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
259 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
262 static reloc_howto_type
*
263 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
267 if (r_type
== (unsigned int) R_X86_64_32
)
272 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
274 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
275 || r_type
>= (unsigned int) R_X86_64_max
)
277 if (r_type
>= (unsigned int) R_X86_64_standard
)
279 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
281 r_type
= R_X86_64_NONE
;
286 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
287 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
288 return &x86_64_elf_howto_table
[i
];
291 /* Given a BFD reloc type, return a HOWTO structure. */
292 static reloc_howto_type
*
293 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
294 bfd_reloc_code_real_type code
)
298 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
301 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
302 return elf_x86_64_rtype_to_howto (abfd
,
303 x86_64_reloc_map
[i
].elf_reloc_val
);
308 static reloc_howto_type
*
309 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
314 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
316 /* Get x32 R_X86_64_32. */
317 reloc_howto_type
*reloc
318 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
319 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
323 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
324 if (x86_64_elf_howto_table
[i
].name
!= NULL
325 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
326 return &x86_64_elf_howto_table
[i
];
331 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
334 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
335 Elf_Internal_Rela
*dst
)
339 r_type
= ELF32_R_TYPE (dst
->r_info
);
340 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
341 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
344 /* Support for core dump NOTE sections. */
346 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
351 switch (note
->descsz
)
356 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
358 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
361 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
369 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
371 elf_tdata (abfd
)->core
->signal
372 = bfd_get_16 (abfd
, note
->descdata
+ 12);
375 elf_tdata (abfd
)->core
->lwpid
376 = bfd_get_32 (abfd
, note
->descdata
+ 32);
385 /* Make a ".reg/999" section. */
386 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
387 size
, note
->descpos
+ offset
);
391 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
393 switch (note
->descsz
)
398 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
399 elf_tdata (abfd
)->core
->pid
400 = bfd_get_32 (abfd
, note
->descdata
+ 12);
401 elf_tdata (abfd
)->core
->program
402 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
403 elf_tdata (abfd
)->core
->command
404 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
407 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 24);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
416 /* Note that for some reason, a spurious space is tacked
417 onto the end of the args in some (at least one anyway)
418 implementations, so strip it off if it exists. */
421 char *command
= elf_tdata (abfd
)->core
->command
;
422 int n
= strlen (command
);
424 if (0 < n
&& command
[n
- 1] == ' ')
425 command
[n
- 1] = '\0';
433 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
436 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
438 const char *fname
, *psargs
;
449 va_start (ap
, note_type
);
450 fname
= va_arg (ap
, const char *);
451 psargs
= va_arg (ap
, const char *);
454 if (bed
->s
->elfclass
== ELFCLASS32
)
457 memset (&data
, 0, sizeof (data
));
458 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
459 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
460 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
461 &data
, sizeof (data
));
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 va_start (ap
, note_type
);
476 pid
= va_arg (ap
, long);
477 cursig
= va_arg (ap
, int);
478 gregs
= va_arg (ap
, const void *);
481 if (bed
->s
->elfclass
== ELFCLASS32
)
483 if (bed
->elf_machine_code
== EM_X86_64
)
485 prstatusx32_t prstat
;
486 memset (&prstat
, 0, sizeof (prstat
));
488 prstat
.pr_cursig
= cursig
;
489 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
490 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
491 &prstat
, sizeof (prstat
));
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
507 memset (&prstat
, 0, sizeof (prstat
));
509 prstat
.pr_cursig
= cursig
;
510 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
511 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
512 &prstat
, sizeof (prstat
));
519 /* Functions for the x86-64 ELF linker. */
521 /* The name of the dynamic interpreter. This is put in the .interp
524 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
525 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
527 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
528 copying dynamic variables from a shared lib into an app's dynbss
529 section, and instead use a dynamic relocation to point into the
531 #define ELIMINATE_COPY_RELOCS 1
533 /* The size in bytes of an entry in the global offset table. */
535 #define GOT_ENTRY_SIZE 8
537 /* The size in bytes of an entry in the procedure linkage table. */
539 #define PLT_ENTRY_SIZE 16
541 /* The first entry in a procedure linkage table looks like this. See the
542 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
544 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
546 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
547 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
548 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
551 /* Subsequent entries in a procedure linkage table look like this. */
553 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
556 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
557 0x68, /* pushq immediate */
558 0, 0, 0, 0, /* replaced with index into relocation table. */
559 0xe9, /* jmp relative */
560 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
563 /* The first entry in a procedure linkage table with BND relocations
566 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
568 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
569 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
570 0x0f, 0x1f, 0 /* nopl (%rax) */
573 /* Subsequent entries for legacy branches in a procedure linkage table
574 with BND relocations look like this. */
576 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
578 0x68, 0, 0, 0, 0, /* pushq immediate */
579 0xe9, 0, 0, 0, 0, /* jmpq relative */
580 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
583 /* Subsequent entries for branches with BND prefx in a procedure linkage
584 table with BND relocations look like this. */
586 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
588 0x68, 0, 0, 0, 0, /* pushq immediate */
589 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
590 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
593 /* Entries for legacy branches in the second procedure linkage table
596 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
598 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
599 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries for branches with BND prefix in the second procedure linkage
604 table look like this. */
606 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
608 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
613 /* .eh_frame covering the .plt section. */
615 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
617 #define PLT_CIE_LENGTH 20
618 #define PLT_FDE_LENGTH 36
619 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
620 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
621 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
622 0, 0, 0, 0, /* CIE ID */
624 'z', 'R', 0, /* Augmentation string */
625 1, /* Code alignment factor */
626 0x78, /* Data alignment factor */
627 16, /* Return address column */
628 1, /* Augmentation size */
629 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
630 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
631 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
632 DW_CFA_nop
, DW_CFA_nop
,
634 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
635 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
636 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
637 0, 0, 0, 0, /* .plt size goes here */
638 0, /* Augmentation size */
639 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
640 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
641 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
642 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
643 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
644 11, /* Block length */
645 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
646 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
647 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
648 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
649 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
652 /* Architecture-specific backend data for x86-64. */
654 struct elf_x86_64_backend_data
656 /* Templates for the initial PLT entry and for subsequent entries. */
657 const bfd_byte
*plt0_entry
;
658 const bfd_byte
*plt_entry
;
659 unsigned int plt_entry_size
; /* Size of each PLT entry. */
661 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
662 unsigned int plt0_got1_offset
;
663 unsigned int plt0_got2_offset
;
665 /* Offset of the end of the PC-relative instruction containing
667 unsigned int plt0_got2_insn_end
;
669 /* Offsets into plt_entry that are to be replaced with... */
670 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
671 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
672 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
674 /* Length of the PC-relative instruction containing plt_got_offset. */
675 unsigned int plt_got_insn_size
;
677 /* Offset of the end of the PC-relative jump to plt0_entry. */
678 unsigned int plt_plt_insn_end
;
680 /* Offset into plt_entry where the initial value of the GOT entry points. */
681 unsigned int plt_lazy_offset
;
683 /* .eh_frame covering the .plt section. */
684 const bfd_byte
*eh_frame_plt
;
685 unsigned int eh_frame_plt_size
;
688 #define get_elf_x86_64_arch_data(bed) \
689 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
691 #define get_elf_x86_64_backend_data(abfd) \
692 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
694 #define GET_PLT_ENTRY_SIZE(abfd) \
695 get_elf_x86_64_backend_data (abfd)->plt_entry_size
697 /* These are the standard parameters. */
698 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
700 elf_x86_64_plt0_entry
, /* plt0_entry */
701 elf_x86_64_plt_entry
, /* plt_entry */
702 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
703 2, /* plt0_got1_offset */
704 8, /* plt0_got2_offset */
705 12, /* plt0_got2_insn_end */
706 2, /* plt_got_offset */
707 7, /* plt_reloc_offset */
708 12, /* plt_plt_offset */
709 6, /* plt_got_insn_size */
710 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
711 6, /* plt_lazy_offset */
712 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
713 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
716 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
718 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
719 elf_x86_64_bnd_plt_entry
, /* plt_entry */
720 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
721 2, /* plt0_got1_offset */
722 1+8, /* plt0_got2_offset */
723 1+12, /* plt0_got2_insn_end */
724 1+2, /* plt_got_offset */
725 1, /* plt_reloc_offset */
726 7, /* plt_plt_offset */
727 1+6, /* plt_got_insn_size */
728 11, /* plt_plt_insn_end */
729 0, /* plt_lazy_offset */
730 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
731 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
734 #define elf_backend_arch_data &elf_x86_64_arch_bed
736 /* x86-64 ELF linker hash entry. */
738 struct elf_x86_64_link_hash_entry
740 struct elf_link_hash_entry elf
;
742 /* Track dynamic relocs copied for this symbol. */
743 struct elf_dyn_relocs
*dyn_relocs
;
745 #define GOT_UNKNOWN 0
749 #define GOT_TLS_GDESC 4
750 #define GOT_TLS_GD_BOTH_P(type) \
751 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
752 #define GOT_TLS_GD_P(type) \
753 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
754 #define GOT_TLS_GDESC_P(type) \
755 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
756 #define GOT_TLS_GD_ANY_P(type) \
757 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
758 unsigned char tls_type
;
760 /* TRUE if a weak symbol with a real definition needs a copy reloc.
761 When there is a weak symbol with a real definition, the processor
762 independent code will have arranged for us to see the real
763 definition first. We need to copy the needs_copy bit from the
764 real definition and check it when allowing copy reloc in PIE. */
765 unsigned int needs_copy
: 1;
767 /* TRUE if symbol has at least one BND relocation. */
768 unsigned int has_bnd_reloc
: 1;
770 /* Information about the GOT PLT entry. Filled when there are both
771 GOT and PLT relocations against the same function. */
772 union gotplt_union plt_got
;
774 /* Information about the second PLT entry. Filled when has_bnd_reloc is
776 union gotplt_union plt_bnd
;
778 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
779 starting at the end of the jump table. */
783 #define elf_x86_64_hash_entry(ent) \
784 ((struct elf_x86_64_link_hash_entry *)(ent))
786 struct elf_x86_64_obj_tdata
788 struct elf_obj_tdata root
;
790 /* tls_type for each local got entry. */
791 char *local_got_tls_type
;
793 /* GOTPLT entries for TLS descriptors. */
794 bfd_vma
*local_tlsdesc_gotent
;
797 #define elf_x86_64_tdata(abfd) \
798 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
800 #define elf_x86_64_local_got_tls_type(abfd) \
801 (elf_x86_64_tdata (abfd)->local_got_tls_type)
803 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
804 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
806 #define is_x86_64_elf(bfd) \
807 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
808 && elf_tdata (bfd) != NULL \
809 && elf_object_id (bfd) == X86_64_ELF_DATA)
812 elf_x86_64_mkobject (bfd
*abfd
)
814 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
818 /* x86-64 ELF linker hash table. */
820 struct elf_x86_64_link_hash_table
822 struct elf_link_hash_table elf
;
824 /* Short-cuts to get to dynamic linker sections. */
827 asection
*plt_eh_frame
;
833 bfd_signed_vma refcount
;
837 /* The amount of space used by the jump slots in the GOT. */
838 bfd_vma sgotplt_jump_table_size
;
840 /* Small local sym cache. */
841 struct sym_cache sym_cache
;
843 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
844 bfd_vma (*r_sym
) (bfd_vma
);
845 unsigned int pointer_r_type
;
846 const char *dynamic_interpreter
;
847 int dynamic_interpreter_size
;
849 /* _TLS_MODULE_BASE_ symbol. */
850 struct bfd_link_hash_entry
*tls_module_base
;
852 /* Used by local STT_GNU_IFUNC symbols. */
853 htab_t loc_hash_table
;
854 void * loc_hash_memory
;
856 /* The offset into splt of the PLT entry for the TLS descriptor
857 resolver. Special values are 0, if not necessary (or not found
858 to be necessary yet), and -1 if needed but not determined
861 /* The offset into sgot of the GOT entry used by the PLT entry
865 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
866 bfd_vma next_jump_slot_index
;
867 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
868 bfd_vma next_irelative_index
;
871 /* Get the x86-64 ELF linker hash table from a link_info structure. */
873 #define elf_x86_64_hash_table(p) \
874 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
875 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
877 #define elf_x86_64_compute_jump_table_size(htab) \
878 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
880 /* Create an entry in an x86-64 ELF linker hash table. */
882 static struct bfd_hash_entry
*
883 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
884 struct bfd_hash_table
*table
,
887 /* Allocate the structure if it has not already been allocated by a
891 entry
= (struct bfd_hash_entry
*)
892 bfd_hash_allocate (table
,
893 sizeof (struct elf_x86_64_link_hash_entry
));
898 /* Call the allocation method of the superclass. */
899 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
902 struct elf_x86_64_link_hash_entry
*eh
;
904 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
905 eh
->dyn_relocs
= NULL
;
906 eh
->tls_type
= GOT_UNKNOWN
;
908 eh
->has_bnd_reloc
= 0;
909 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
910 eh
->plt_got
.offset
= (bfd_vma
) -1;
911 eh
->tlsdesc_got
= (bfd_vma
) -1;
917 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
918 for local symbol so that we can handle local STT_GNU_IFUNC symbols
919 as global symbol. We reuse indx and dynstr_index for local symbol
920 hash since they aren't used by global symbols in this backend. */
923 elf_x86_64_local_htab_hash (const void *ptr
)
925 struct elf_link_hash_entry
*h
926 = (struct elf_link_hash_entry
*) ptr
;
927 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
930 /* Compare local hash entries. */
933 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
935 struct elf_link_hash_entry
*h1
936 = (struct elf_link_hash_entry
*) ptr1
;
937 struct elf_link_hash_entry
*h2
938 = (struct elf_link_hash_entry
*) ptr2
;
940 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
943 /* Find and/or create a hash entry for local symbol. */
945 static struct elf_link_hash_entry
*
946 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
947 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
950 struct elf_x86_64_link_hash_entry e
, *ret
;
951 asection
*sec
= abfd
->sections
;
952 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
953 htab
->r_sym (rel
->r_info
));
956 e
.elf
.indx
= sec
->id
;
957 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
958 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
959 create
? INSERT
: NO_INSERT
);
966 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
970 ret
= (struct elf_x86_64_link_hash_entry
*)
971 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
972 sizeof (struct elf_x86_64_link_hash_entry
));
975 memset (ret
, 0, sizeof (*ret
));
976 ret
->elf
.indx
= sec
->id
;
977 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
978 ret
->elf
.dynindx
= -1;
979 ret
->plt_got
.offset
= (bfd_vma
) -1;
985 /* Destroy an X86-64 ELF linker hash table. */
988 elf_x86_64_link_hash_table_free (bfd
*obfd
)
990 struct elf_x86_64_link_hash_table
*htab
991 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
993 if (htab
->loc_hash_table
)
994 htab_delete (htab
->loc_hash_table
);
995 if (htab
->loc_hash_memory
)
996 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
997 _bfd_elf_link_hash_table_free (obfd
);
1000 /* Create an X86-64 ELF linker hash table. */
1002 static struct bfd_link_hash_table
*
1003 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1005 struct elf_x86_64_link_hash_table
*ret
;
1006 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1008 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1012 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1013 elf_x86_64_link_hash_newfunc
,
1014 sizeof (struct elf_x86_64_link_hash_entry
),
1021 if (ABI_64_P (abfd
))
1023 ret
->r_info
= elf64_r_info
;
1024 ret
->r_sym
= elf64_r_sym
;
1025 ret
->pointer_r_type
= R_X86_64_64
;
1026 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1027 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1031 ret
->r_info
= elf32_r_info
;
1032 ret
->r_sym
= elf32_r_sym
;
1033 ret
->pointer_r_type
= R_X86_64_32
;
1034 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1035 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1038 ret
->loc_hash_table
= htab_try_create (1024,
1039 elf_x86_64_local_htab_hash
,
1040 elf_x86_64_local_htab_eq
,
1042 ret
->loc_hash_memory
= objalloc_create ();
1043 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1045 elf_x86_64_link_hash_table_free (abfd
);
1048 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1050 return &ret
->elf
.root
;
1053 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1054 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1059 struct bfd_link_info
*info
)
1061 struct elf_x86_64_link_hash_table
*htab
;
1063 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1066 htab
= elf_x86_64_hash_table (info
);
1070 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1074 if (info
->executable
)
1076 /* Always allow copy relocs for building executables. */
1077 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1080 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1081 s
= bfd_make_section_anyway_with_flags (dynobj
,
1083 (bed
->dynamic_sec_flags
1086 || ! bfd_set_section_alignment (dynobj
, s
,
1087 bed
->s
->log_file_align
))
1093 if (!info
->no_ld_generated_unwind_info
1094 && htab
->plt_eh_frame
== NULL
1095 && htab
->elf
.splt
!= NULL
)
1097 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1098 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1099 | SEC_LINKER_CREATED
);
1101 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1102 if (htab
->plt_eh_frame
== NULL
1103 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1109 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1112 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1113 struct elf_link_hash_entry
*dir
,
1114 struct elf_link_hash_entry
*ind
)
1116 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1118 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1119 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1121 if (!edir
->has_bnd_reloc
)
1122 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1124 if (eind
->dyn_relocs
!= NULL
)
1126 if (edir
->dyn_relocs
!= NULL
)
1128 struct elf_dyn_relocs
**pp
;
1129 struct elf_dyn_relocs
*p
;
1131 /* Add reloc counts against the indirect sym to the direct sym
1132 list. Merge any entries against the same section. */
1133 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1135 struct elf_dyn_relocs
*q
;
1137 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1138 if (q
->sec
== p
->sec
)
1140 q
->pc_count
+= p
->pc_count
;
1141 q
->count
+= p
->count
;
1148 *pp
= edir
->dyn_relocs
;
1151 edir
->dyn_relocs
= eind
->dyn_relocs
;
1152 eind
->dyn_relocs
= NULL
;
1155 if (ind
->root
.type
== bfd_link_hash_indirect
1156 && dir
->got
.refcount
<= 0)
1158 edir
->tls_type
= eind
->tls_type
;
1159 eind
->tls_type
= GOT_UNKNOWN
;
1162 if (ELIMINATE_COPY_RELOCS
1163 && ind
->root
.type
!= bfd_link_hash_indirect
1164 && dir
->dynamic_adjusted
)
1166 /* If called to transfer flags for a weakdef during processing
1167 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1168 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1169 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1170 dir
->ref_regular
|= ind
->ref_regular
;
1171 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1172 dir
->needs_plt
|= ind
->needs_plt
;
1173 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1176 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1180 elf64_x86_64_elf_object_p (bfd
*abfd
)
1182 /* Set the right machine number for an x86-64 elf64 file. */
1183 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1188 elf32_x86_64_elf_object_p (bfd
*abfd
)
1190 /* Set the right machine number for an x86-64 elf32 file. */
1191 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1195 /* Return TRUE if the TLS access code sequence support transition
1199 elf_x86_64_check_tls_transition (bfd
*abfd
,
1200 struct bfd_link_info
*info
,
1203 Elf_Internal_Shdr
*symtab_hdr
,
1204 struct elf_link_hash_entry
**sym_hashes
,
1205 unsigned int r_type
,
1206 const Elf_Internal_Rela
*rel
,
1207 const Elf_Internal_Rela
*relend
)
1210 unsigned long r_symndx
;
1211 bfd_boolean largepic
= FALSE
;
1212 struct elf_link_hash_entry
*h
;
1214 struct elf_x86_64_link_hash_table
*htab
;
1216 /* Get the section contents. */
1217 if (contents
== NULL
)
1219 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1220 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1223 /* FIXME: How to better handle error condition? */
1224 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1227 /* Cache the section contents for elf_link_input_bfd. */
1228 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1232 htab
= elf_x86_64_hash_table (info
);
1233 offset
= rel
->r_offset
;
1236 case R_X86_64_TLSGD
:
1237 case R_X86_64_TLSLD
:
1238 if ((rel
+ 1) >= relend
)
1241 if (r_type
== R_X86_64_TLSGD
)
1243 /* Check transition from GD access model. For 64bit, only
1244 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1245 .word 0x6666; rex64; call __tls_get_addr
1246 can transit to different access model. For 32bit, only
1247 leaq foo@tlsgd(%rip), %rdi
1248 .word 0x6666; rex64; call __tls_get_addr
1249 can transit to different access model. For largepic
1251 leaq foo@tlsgd(%rip), %rdi
1252 movabsq $__tls_get_addr@pltoff, %rax
1256 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1257 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1259 if ((offset
+ 12) > sec
->size
)
1262 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1264 if (!ABI_64_P (abfd
)
1265 || (offset
+ 19) > sec
->size
1267 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1268 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1269 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1274 else if (ABI_64_P (abfd
))
1277 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1283 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1289 /* Check transition from LD access model. Only
1290 leaq foo@tlsld(%rip), %rdi;
1292 can transit to different access model. For largepic
1294 leaq foo@tlsld(%rip), %rdi
1295 movabsq $__tls_get_addr@pltoff, %rax
1299 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1301 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1304 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1307 if (0xe8 != *(contents
+ offset
+ 4))
1309 if (!ABI_64_P (abfd
)
1310 || (offset
+ 19) > sec
->size
1311 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1312 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1319 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1320 if (r_symndx
< symtab_hdr
->sh_info
)
1323 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1324 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1325 may be versioned. */
1327 && h
->root
.root
.string
!= NULL
1329 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1330 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1331 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1332 && (strncmp (h
->root
.root
.string
,
1333 "__tls_get_addr", 14) == 0));
1335 case R_X86_64_GOTTPOFF
:
1336 /* Check transition from IE access model:
1337 mov foo@gottpoff(%rip), %reg
1338 add foo@gottpoff(%rip), %reg
1341 /* Check REX prefix first. */
1342 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1344 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1345 if (val
!= 0x48 && val
!= 0x4c)
1347 /* X32 may have 0x44 REX prefix or no REX prefix. */
1348 if (ABI_64_P (abfd
))
1354 /* X32 may not have any REX prefix. */
1355 if (ABI_64_P (abfd
))
1357 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1361 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1362 if (val
!= 0x8b && val
!= 0x03)
1365 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1366 return (val
& 0xc7) == 5;
1368 case R_X86_64_GOTPC32_TLSDESC
:
1369 /* Check transition from GDesc access model:
1370 leaq x@tlsdesc(%rip), %rax
1372 Make sure it's a leaq adding rip to a 32-bit offset
1373 into any register, although it's probably almost always
1376 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1379 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1380 if ((val
& 0xfb) != 0x48)
1383 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1386 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1387 return (val
& 0xc7) == 0x05;
1389 case R_X86_64_TLSDESC_CALL
:
1390 /* Check transition from GDesc access model:
1391 call *x@tlsdesc(%rax)
1393 if (offset
+ 2 <= sec
->size
)
1395 /* Make sure that it's a call *x@tlsdesc(%rax). */
1396 static const unsigned char call
[] = { 0xff, 0x10 };
1397 return memcmp (contents
+ offset
, call
, 2) == 0;
1407 /* Return TRUE if the TLS access transition is OK or no transition
1408 will be performed. Update R_TYPE if there is a transition. */
1411 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1412 asection
*sec
, bfd_byte
*contents
,
1413 Elf_Internal_Shdr
*symtab_hdr
,
1414 struct elf_link_hash_entry
**sym_hashes
,
1415 unsigned int *r_type
, int tls_type
,
1416 const Elf_Internal_Rela
*rel
,
1417 const Elf_Internal_Rela
*relend
,
1418 struct elf_link_hash_entry
*h
,
1419 unsigned long r_symndx
)
1421 unsigned int from_type
= *r_type
;
1422 unsigned int to_type
= from_type
;
1423 bfd_boolean check
= TRUE
;
1425 /* Skip TLS transition for functions. */
1427 && (h
->type
== STT_FUNC
1428 || h
->type
== STT_GNU_IFUNC
))
1433 case R_X86_64_TLSGD
:
1434 case R_X86_64_GOTPC32_TLSDESC
:
1435 case R_X86_64_TLSDESC_CALL
:
1436 case R_X86_64_GOTTPOFF
:
1437 if (info
->executable
)
1440 to_type
= R_X86_64_TPOFF32
;
1442 to_type
= R_X86_64_GOTTPOFF
;
1445 /* When we are called from elf_x86_64_relocate_section,
1446 CONTENTS isn't NULL and there may be additional transitions
1447 based on TLS_TYPE. */
1448 if (contents
!= NULL
)
1450 unsigned int new_to_type
= to_type
;
1452 if (info
->executable
1455 && tls_type
== GOT_TLS_IE
)
1456 new_to_type
= R_X86_64_TPOFF32
;
1458 if (to_type
== R_X86_64_TLSGD
1459 || to_type
== R_X86_64_GOTPC32_TLSDESC
1460 || to_type
== R_X86_64_TLSDESC_CALL
)
1462 if (tls_type
== GOT_TLS_IE
)
1463 new_to_type
= R_X86_64_GOTTPOFF
;
1466 /* We checked the transition before when we were called from
1467 elf_x86_64_check_relocs. We only want to check the new
1468 transition which hasn't been checked before. */
1469 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1470 to_type
= new_to_type
;
1475 case R_X86_64_TLSLD
:
1476 if (info
->executable
)
1477 to_type
= R_X86_64_TPOFF32
;
1484 /* Return TRUE if there is no transition. */
1485 if (from_type
== to_type
)
1488 /* Check if the transition can be performed. */
1490 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1491 symtab_hdr
, sym_hashes
,
1492 from_type
, rel
, relend
))
1494 reloc_howto_type
*from
, *to
;
1497 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1498 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1501 name
= h
->root
.root
.string
;
1504 struct elf_x86_64_link_hash_table
*htab
;
1506 htab
= elf_x86_64_hash_table (info
);
1511 Elf_Internal_Sym
*isym
;
1513 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1515 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1519 (*_bfd_error_handler
)
1520 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1521 "in section `%A' failed"),
1522 abfd
, sec
, from
->name
, to
->name
, name
,
1523 (unsigned long) rel
->r_offset
);
1524 bfd_set_error (bfd_error_bad_value
);
1532 /* Rename some of the generic section flags to better document how they
1534 #define need_convert_mov_to_lea sec_flg0
1536 /* Look through the relocs for a section during the first phase, and
1537 calculate needed space in the global offset table, procedure
1538 linkage table, and dynamic reloc sections. */
1541 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1543 const Elf_Internal_Rela
*relocs
)
1545 struct elf_x86_64_link_hash_table
*htab
;
1546 Elf_Internal_Shdr
*symtab_hdr
;
1547 struct elf_link_hash_entry
**sym_hashes
;
1548 const Elf_Internal_Rela
*rel
;
1549 const Elf_Internal_Rela
*rel_end
;
1551 bfd_boolean use_plt_got
;
1553 if (info
->relocatable
)
1556 BFD_ASSERT (is_x86_64_elf (abfd
));
1558 htab
= elf_x86_64_hash_table (info
);
1562 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1564 symtab_hdr
= &elf_symtab_hdr (abfd
);
1565 sym_hashes
= elf_sym_hashes (abfd
);
1569 rel_end
= relocs
+ sec
->reloc_count
;
1570 for (rel
= relocs
; rel
< rel_end
; rel
++)
1572 unsigned int r_type
;
1573 unsigned long r_symndx
;
1574 struct elf_link_hash_entry
*h
;
1575 Elf_Internal_Sym
*isym
;
1577 bfd_boolean size_reloc
;
1579 r_symndx
= htab
->r_sym (rel
->r_info
);
1580 r_type
= ELF32_R_TYPE (rel
->r_info
);
1582 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1584 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1589 if (r_symndx
< symtab_hdr
->sh_info
)
1591 /* A local symbol. */
1592 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1597 /* Check relocation against local STT_GNU_IFUNC symbol. */
1598 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1600 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1605 /* Fake a STT_GNU_IFUNC symbol. */
1606 h
->type
= STT_GNU_IFUNC
;
1609 h
->forced_local
= 1;
1610 h
->root
.type
= bfd_link_hash_defined
;
1618 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1619 while (h
->root
.type
== bfd_link_hash_indirect
1620 || h
->root
.type
== bfd_link_hash_warning
)
1621 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1624 /* Check invalid x32 relocations. */
1625 if (!ABI_64_P (abfd
))
1631 case R_X86_64_DTPOFF64
:
1632 case R_X86_64_TPOFF64
:
1634 case R_X86_64_GOTOFF64
:
1635 case R_X86_64_GOT64
:
1636 case R_X86_64_GOTPCREL64
:
1637 case R_X86_64_GOTPC64
:
1638 case R_X86_64_GOTPLT64
:
1639 case R_X86_64_PLTOFF64
:
1642 name
= h
->root
.root
.string
;
1644 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1646 (*_bfd_error_handler
)
1647 (_("%B: relocation %s against symbol `%s' isn't "
1648 "supported in x32 mode"), abfd
,
1649 x86_64_elf_howto_table
[r_type
].name
, name
);
1650 bfd_set_error (bfd_error_bad_value
);
1658 /* Create the ifunc sections for static executables. If we
1659 never see an indirect function symbol nor we are building
1660 a static executable, those sections will be empty and
1661 won't appear in output. */
1667 case R_X86_64_PC32_BND
:
1668 case R_X86_64_PLT32_BND
:
1670 case R_X86_64_PLT32
:
1673 /* MPX PLT is supported only if elf_x86_64_arch_bed
1674 is used in 64-bit mode. */
1677 && (get_elf_x86_64_backend_data (abfd
)
1678 == &elf_x86_64_arch_bed
))
1680 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1682 /* Create the second PLT for Intel MPX support. */
1683 if (htab
->plt_bnd
== NULL
)
1685 unsigned int plt_bnd_align
;
1686 const struct elf_backend_data
*bed
;
1688 bed
= get_elf_backend_data (info
->output_bfd
);
1689 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1690 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1691 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1694 if (htab
->elf
.dynobj
== NULL
)
1695 htab
->elf
.dynobj
= abfd
;
1697 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1699 (bed
->dynamic_sec_flags
1704 if (htab
->plt_bnd
== NULL
1705 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1714 case R_X86_64_GOTPCREL
:
1715 case R_X86_64_GOTPCREL64
:
1716 if (htab
->elf
.dynobj
== NULL
)
1717 htab
->elf
.dynobj
= abfd
;
1718 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1723 /* It is referenced by a non-shared object. */
1725 h
->root
.non_ir_ref
= 1;
1728 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1729 symtab_hdr
, sym_hashes
,
1730 &r_type
, GOT_UNKNOWN
,
1731 rel
, rel_end
, h
, r_symndx
))
1736 case R_X86_64_TLSLD
:
1737 htab
->tls_ld_got
.refcount
+= 1;
1740 case R_X86_64_TPOFF32
:
1741 if (!info
->executable
&& ABI_64_P (abfd
))
1744 name
= h
->root
.root
.string
;
1746 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1748 (*_bfd_error_handler
)
1749 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1751 x86_64_elf_howto_table
[r_type
].name
, name
);
1752 bfd_set_error (bfd_error_bad_value
);
1757 case R_X86_64_GOTTPOFF
:
1758 if (!info
->executable
)
1759 info
->flags
|= DF_STATIC_TLS
;
1762 case R_X86_64_GOT32
:
1763 case R_X86_64_GOTPCREL
:
1764 case R_X86_64_TLSGD
:
1765 case R_X86_64_GOT64
:
1766 case R_X86_64_GOTPCREL64
:
1767 case R_X86_64_GOTPLT64
:
1768 case R_X86_64_GOTPC32_TLSDESC
:
1769 case R_X86_64_TLSDESC_CALL
:
1770 /* This symbol requires a global offset table entry. */
1772 int tls_type
, old_tls_type
;
1776 default: tls_type
= GOT_NORMAL
; break;
1777 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1778 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1779 case R_X86_64_GOTPC32_TLSDESC
:
1780 case R_X86_64_TLSDESC_CALL
:
1781 tls_type
= GOT_TLS_GDESC
; break;
1786 h
->got
.refcount
+= 1;
1787 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1791 bfd_signed_vma
*local_got_refcounts
;
1793 /* This is a global offset table entry for a local symbol. */
1794 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1795 if (local_got_refcounts
== NULL
)
1799 size
= symtab_hdr
->sh_info
;
1800 size
*= sizeof (bfd_signed_vma
)
1801 + sizeof (bfd_vma
) + sizeof (char);
1802 local_got_refcounts
= ((bfd_signed_vma
*)
1803 bfd_zalloc (abfd
, size
));
1804 if (local_got_refcounts
== NULL
)
1806 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1807 elf_x86_64_local_tlsdesc_gotent (abfd
)
1808 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1809 elf_x86_64_local_got_tls_type (abfd
)
1810 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1812 local_got_refcounts
[r_symndx
] += 1;
1814 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1817 /* If a TLS symbol is accessed using IE at least once,
1818 there is no point to use dynamic model for it. */
1819 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1820 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1821 || tls_type
!= GOT_TLS_IE
))
1823 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1824 tls_type
= old_tls_type
;
1825 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1826 && GOT_TLS_GD_ANY_P (tls_type
))
1827 tls_type
|= old_tls_type
;
1831 name
= h
->root
.root
.string
;
1833 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1835 (*_bfd_error_handler
)
1836 (_("%B: '%s' accessed both as normal and thread local symbol"),
1838 bfd_set_error (bfd_error_bad_value
);
1843 if (old_tls_type
!= tls_type
)
1846 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1848 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1853 case R_X86_64_GOTOFF64
:
1854 case R_X86_64_GOTPC32
:
1855 case R_X86_64_GOTPC64
:
1857 if (htab
->elf
.sgot
== NULL
)
1859 if (htab
->elf
.dynobj
== NULL
)
1860 htab
->elf
.dynobj
= abfd
;
1861 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1867 case R_X86_64_PLT32
:
1868 case R_X86_64_PLT32_BND
:
1869 /* This symbol requires a procedure linkage table entry. We
1870 actually build the entry in adjust_dynamic_symbol,
1871 because this might be a case of linking PIC code which is
1872 never referenced by a dynamic object, in which case we
1873 don't need to generate a procedure linkage table entry
1876 /* If this is a local symbol, we resolve it directly without
1877 creating a procedure linkage table entry. */
1882 h
->plt
.refcount
+= 1;
1885 case R_X86_64_PLTOFF64
:
1886 /* This tries to form the 'address' of a function relative
1887 to GOT. For global symbols we need a PLT entry. */
1891 h
->plt
.refcount
+= 1;
1895 case R_X86_64_SIZE32
:
1896 case R_X86_64_SIZE64
:
1901 if (!ABI_64_P (abfd
))
1906 /* Let's help debug shared library creation. These relocs
1907 cannot be used in shared libs. Don't error out for
1908 sections we don't care about, such as debug sections or
1909 non-constant sections. */
1911 && (sec
->flags
& SEC_ALLOC
) != 0
1912 && (sec
->flags
& SEC_READONLY
) != 0)
1915 name
= h
->root
.root
.string
;
1917 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1918 (*_bfd_error_handler
)
1919 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1920 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1921 bfd_set_error (bfd_error_bad_value
);
1929 case R_X86_64_PC32_BND
:
1933 if (h
!= NULL
&& info
->executable
)
1935 /* If this reloc is in a read-only section, we might
1936 need a copy reloc. We can't check reliably at this
1937 stage whether the section is read-only, as input
1938 sections have not yet been mapped to output sections.
1939 Tentatively set the flag for now, and correct in
1940 adjust_dynamic_symbol. */
1943 /* We may need a .plt entry if the function this reloc
1944 refers to is in a shared lib. */
1945 h
->plt
.refcount
+= 1;
1946 if (r_type
!= R_X86_64_PC32
1947 && r_type
!= R_X86_64_PC32_BND
1948 && r_type
!= R_X86_64_PC64
)
1949 h
->pointer_equality_needed
= 1;
1954 /* If we are creating a shared library, and this is a reloc
1955 against a global symbol, or a non PC relative reloc
1956 against a local symbol, then we need to copy the reloc
1957 into the shared library. However, if we are linking with
1958 -Bsymbolic, we do not need to copy a reloc against a
1959 global symbol which is defined in an object we are
1960 including in the link (i.e., DEF_REGULAR is set). At
1961 this point we have not seen all the input files, so it is
1962 possible that DEF_REGULAR is not set now but will be set
1963 later (it is never cleared). In case of a weak definition,
1964 DEF_REGULAR may be cleared later by a strong definition in
1965 a shared library. We account for that possibility below by
1966 storing information in the relocs_copied field of the hash
1967 table entry. A similar situation occurs when creating
1968 shared libraries and symbol visibility changes render the
1971 If on the other hand, we are creating an executable, we
1972 may need to keep relocations for symbols satisfied by a
1973 dynamic library if we manage to avoid copy relocs for the
1976 && (sec
->flags
& SEC_ALLOC
) != 0
1977 && (! IS_X86_64_PCREL_TYPE (r_type
)
1979 && (! SYMBOLIC_BIND (info
, h
)
1980 || h
->root
.type
== bfd_link_hash_defweak
1981 || !h
->def_regular
))))
1982 || (ELIMINATE_COPY_RELOCS
1984 && (sec
->flags
& SEC_ALLOC
) != 0
1986 && (h
->root
.type
== bfd_link_hash_defweak
1987 || !h
->def_regular
)))
1989 struct elf_dyn_relocs
*p
;
1990 struct elf_dyn_relocs
**head
;
1992 /* We must copy these reloc types into the output file.
1993 Create a reloc section in dynobj and make room for
1997 if (htab
->elf
.dynobj
== NULL
)
1998 htab
->elf
.dynobj
= abfd
;
2000 sreloc
= _bfd_elf_make_dynamic_reloc_section
2001 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2002 abfd
, /*rela?*/ TRUE
);
2008 /* If this is a global symbol, we count the number of
2009 relocations we need for this symbol. */
2012 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
2016 /* Track dynamic relocs needed for local syms too.
2017 We really need local syms available to do this
2022 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2027 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2031 /* Beware of type punned pointers vs strict aliasing
2033 vpp
= &(elf_section_data (s
)->local_dynrel
);
2034 head
= (struct elf_dyn_relocs
**)vpp
;
2038 if (p
== NULL
|| p
->sec
!= sec
)
2040 bfd_size_type amt
= sizeof *p
;
2042 p
= ((struct elf_dyn_relocs
*)
2043 bfd_alloc (htab
->elf
.dynobj
, amt
));
2054 /* Count size relocation as PC-relative relocation. */
2055 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2060 /* This relocation describes the C++ object vtable hierarchy.
2061 Reconstruct it for later use during GC. */
2062 case R_X86_64_GNU_VTINHERIT
:
2063 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2067 /* This relocation describes which C++ vtable entries are actually
2068 used. Record for later use during GC. */
2069 case R_X86_64_GNU_VTENTRY
:
2070 BFD_ASSERT (h
!= NULL
);
2072 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2082 && h
->plt
.refcount
> 0
2083 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2084 || h
->got
.refcount
> 0)
2085 && htab
->plt_got
== NULL
)
2087 /* Create the GOT procedure linkage table. */
2088 unsigned int plt_got_align
;
2089 const struct elf_backend_data
*bed
;
2091 bed
= get_elf_backend_data (info
->output_bfd
);
2092 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2093 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2094 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2097 if (htab
->elf
.dynobj
== NULL
)
2098 htab
->elf
.dynobj
= abfd
;
2100 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2102 (bed
->dynamic_sec_flags
2107 if (htab
->plt_got
== NULL
2108 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2114 if (r_type
== R_X86_64_GOTPCREL
2115 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2116 sec
->need_convert_mov_to_lea
= 1;
2122 /* Return the section that should be marked against GC for a given
2126 elf_x86_64_gc_mark_hook (asection
*sec
,
2127 struct bfd_link_info
*info
,
2128 Elf_Internal_Rela
*rel
,
2129 struct elf_link_hash_entry
*h
,
2130 Elf_Internal_Sym
*sym
)
2133 switch (ELF32_R_TYPE (rel
->r_info
))
2135 case R_X86_64_GNU_VTINHERIT
:
2136 case R_X86_64_GNU_VTENTRY
:
2140 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2143 /* Update the got entry reference counts for the section being removed. */
2146 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2148 const Elf_Internal_Rela
*relocs
)
2150 struct elf_x86_64_link_hash_table
*htab
;
2151 Elf_Internal_Shdr
*symtab_hdr
;
2152 struct elf_link_hash_entry
**sym_hashes
;
2153 bfd_signed_vma
*local_got_refcounts
;
2154 const Elf_Internal_Rela
*rel
, *relend
;
2156 if (info
->relocatable
)
2159 htab
= elf_x86_64_hash_table (info
);
2163 elf_section_data (sec
)->local_dynrel
= NULL
;
2165 symtab_hdr
= &elf_symtab_hdr (abfd
);
2166 sym_hashes
= elf_sym_hashes (abfd
);
2167 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2169 htab
= elf_x86_64_hash_table (info
);
2170 relend
= relocs
+ sec
->reloc_count
;
2171 for (rel
= relocs
; rel
< relend
; rel
++)
2173 unsigned long r_symndx
;
2174 unsigned int r_type
;
2175 struct elf_link_hash_entry
*h
= NULL
;
2177 r_symndx
= htab
->r_sym (rel
->r_info
);
2178 if (r_symndx
>= symtab_hdr
->sh_info
)
2180 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2181 while (h
->root
.type
== bfd_link_hash_indirect
2182 || h
->root
.type
== bfd_link_hash_warning
)
2183 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2187 /* A local symbol. */
2188 Elf_Internal_Sym
*isym
;
2190 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2193 /* Check relocation against local STT_GNU_IFUNC symbol. */
2195 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2197 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2205 struct elf_x86_64_link_hash_entry
*eh
;
2206 struct elf_dyn_relocs
**pp
;
2207 struct elf_dyn_relocs
*p
;
2209 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2211 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2214 /* Everything must go for SEC. */
2220 r_type
= ELF32_R_TYPE (rel
->r_info
);
2221 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2222 symtab_hdr
, sym_hashes
,
2223 &r_type
, GOT_UNKNOWN
,
2224 rel
, relend
, h
, r_symndx
))
2229 case R_X86_64_TLSLD
:
2230 if (htab
->tls_ld_got
.refcount
> 0)
2231 htab
->tls_ld_got
.refcount
-= 1;
2234 case R_X86_64_TLSGD
:
2235 case R_X86_64_GOTPC32_TLSDESC
:
2236 case R_X86_64_TLSDESC_CALL
:
2237 case R_X86_64_GOTTPOFF
:
2238 case R_X86_64_GOT32
:
2239 case R_X86_64_GOTPCREL
:
2240 case R_X86_64_GOT64
:
2241 case R_X86_64_GOTPCREL64
:
2242 case R_X86_64_GOTPLT64
:
2245 if (h
->got
.refcount
> 0)
2246 h
->got
.refcount
-= 1;
2247 if (h
->type
== STT_GNU_IFUNC
)
2249 if (h
->plt
.refcount
> 0)
2250 h
->plt
.refcount
-= 1;
2253 else if (local_got_refcounts
!= NULL
)
2255 if (local_got_refcounts
[r_symndx
] > 0)
2256 local_got_refcounts
[r_symndx
] -= 1;
2268 case R_X86_64_PC32_BND
:
2270 case R_X86_64_SIZE32
:
2271 case R_X86_64_SIZE64
:
2273 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2277 case R_X86_64_PLT32
:
2278 case R_X86_64_PLT32_BND
:
2279 case R_X86_64_PLTOFF64
:
2282 if (h
->plt
.refcount
> 0)
2283 h
->plt
.refcount
-= 1;
2295 /* Adjust a symbol defined by a dynamic object and referenced by a
2296 regular object. The current definition is in some section of the
2297 dynamic object, but we're not including those sections. We have to
2298 change the definition to something the rest of the link can
2302 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2303 struct elf_link_hash_entry
*h
)
2305 struct elf_x86_64_link_hash_table
*htab
;
2307 struct elf_x86_64_link_hash_entry
*eh
;
2308 struct elf_dyn_relocs
*p
;
2310 /* STT_GNU_IFUNC symbol must go through PLT. */
2311 if (h
->type
== STT_GNU_IFUNC
)
2313 /* All local STT_GNU_IFUNC references must be treate as local
2314 calls via local PLT. */
2316 && SYMBOL_CALLS_LOCAL (info
, h
))
2318 bfd_size_type pc_count
= 0, count
= 0;
2319 struct elf_dyn_relocs
**pp
;
2321 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2322 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2324 pc_count
+= p
->pc_count
;
2325 p
->count
-= p
->pc_count
;
2334 if (pc_count
|| count
)
2338 if (h
->plt
.refcount
<= 0)
2339 h
->plt
.refcount
= 1;
2341 h
->plt
.refcount
+= 1;
2345 if (h
->plt
.refcount
<= 0)
2347 h
->plt
.offset
= (bfd_vma
) -1;
2353 /* If this is a function, put it in the procedure linkage table. We
2354 will fill in the contents of the procedure linkage table later,
2355 when we know the address of the .got section. */
2356 if (h
->type
== STT_FUNC
2359 if (h
->plt
.refcount
<= 0
2360 || SYMBOL_CALLS_LOCAL (info
, h
)
2361 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2362 && h
->root
.type
== bfd_link_hash_undefweak
))
2364 /* This case can occur if we saw a PLT32 reloc in an input
2365 file, but the symbol was never referred to by a dynamic
2366 object, or if all references were garbage collected. In
2367 such a case, we don't actually need to build a procedure
2368 linkage table, and we can just do a PC32 reloc instead. */
2369 h
->plt
.offset
= (bfd_vma
) -1;
2376 /* It's possible that we incorrectly decided a .plt reloc was
2377 needed for an R_X86_64_PC32 reloc to a non-function sym in
2378 check_relocs. We can't decide accurately between function and
2379 non-function syms in check-relocs; Objects loaded later in
2380 the link may change h->type. So fix it now. */
2381 h
->plt
.offset
= (bfd_vma
) -1;
2383 /* If this is a weak symbol, and there is a real definition, the
2384 processor independent code will have arranged for us to see the
2385 real definition first, and we can just use the same value. */
2386 if (h
->u
.weakdef
!= NULL
)
2388 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2389 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2390 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2391 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2392 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2394 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2395 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2396 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2401 /* This is a reference to a symbol defined by a dynamic object which
2402 is not a function. */
2404 /* If we are creating a shared library, we must presume that the
2405 only references to the symbol are via the global offset table.
2406 For such cases we need not do anything here; the relocations will
2407 be handled correctly by relocate_section. */
2408 if (!info
->executable
)
2411 /* If there are no references to this symbol that do not use the
2412 GOT, we don't need to generate a copy reloc. */
2413 if (!h
->non_got_ref
)
2416 /* If -z nocopyreloc was given, we won't generate them either. */
2417 if (info
->nocopyreloc
)
2423 if (ELIMINATE_COPY_RELOCS
)
2425 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2426 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2428 s
= p
->sec
->output_section
;
2429 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2433 /* If we didn't find any dynamic relocs in read-only sections, then
2434 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2442 /* We must allocate the symbol in our .dynbss section, which will
2443 become part of the .bss section of the executable. There will be
2444 an entry for this symbol in the .dynsym section. The dynamic
2445 object will contain position independent code, so all references
2446 from the dynamic object to this symbol will go through the global
2447 offset table. The dynamic linker will use the .dynsym entry to
2448 determine the address it must put in the global offset table, so
2449 both the dynamic object and the regular object will refer to the
2450 same memory location for the variable. */
2452 htab
= elf_x86_64_hash_table (info
);
2456 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2457 to copy the initial value out of the dynamic object and into the
2458 runtime process image. */
2459 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2461 const struct elf_backend_data
*bed
;
2462 bed
= get_elf_backend_data (info
->output_bfd
);
2463 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2469 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2472 /* Allocate space in .plt, .got and associated reloc sections for
2476 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2478 struct bfd_link_info
*info
;
2479 struct elf_x86_64_link_hash_table
*htab
;
2480 struct elf_x86_64_link_hash_entry
*eh
;
2481 struct elf_dyn_relocs
*p
;
2482 const struct elf_backend_data
*bed
;
2483 unsigned int plt_entry_size
;
2485 if (h
->root
.type
== bfd_link_hash_indirect
)
2488 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2490 info
= (struct bfd_link_info
*) inf
;
2491 htab
= elf_x86_64_hash_table (info
);
2494 bed
= get_elf_backend_data (info
->output_bfd
);
2495 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2497 /* We can't use the GOT PLT if pointer equality is needed since
2498 finish_dynamic_symbol won't clear symbol value and the dynamic
2499 linker won't update the GOT slot. We will get into an infinite
2500 loop at run-time. */
2501 if (htab
->plt_got
!= NULL
2502 && h
->type
!= STT_GNU_IFUNC
2503 && !h
->pointer_equality_needed
2504 && h
->plt
.refcount
> 0
2505 && h
->got
.refcount
> 0)
2507 /* Don't use the regular PLT if there are both GOT and GOTPLT
2509 h
->plt
.offset
= (bfd_vma
) -1;
2511 /* Use the GOT PLT. */
2512 eh
->plt_got
.refcount
= 1;
2515 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2516 here if it is defined and referenced in a non-shared object. */
2517 if (h
->type
== STT_GNU_IFUNC
2520 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2526 asection
*s
= htab
->plt_bnd
;
2527 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2529 /* Use the .plt.bnd section if it is created. */
2530 eh
->plt_bnd
.offset
= s
->size
;
2532 /* Make room for this entry in the .plt.bnd section. */
2533 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2541 else if (htab
->elf
.dynamic_sections_created
2542 && (h
->plt
.refcount
> 0 || eh
->plt_got
.refcount
> 0))
2544 bfd_boolean use_plt_got
;
2546 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2548 /* Don't use the regular PLT for DF_BIND_NOW. */
2549 h
->plt
.offset
= (bfd_vma
) -1;
2551 /* Use the GOT PLT. */
2552 h
->got
.refcount
= 1;
2553 eh
->plt_got
.refcount
= 1;
2556 use_plt_got
= eh
->plt_got
.refcount
> 0;
2558 /* Make sure this symbol is output as a dynamic symbol.
2559 Undefined weak syms won't yet be marked as dynamic. */
2560 if (h
->dynindx
== -1
2561 && !h
->forced_local
)
2563 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2568 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2570 asection
*s
= htab
->elf
.splt
;
2571 asection
*bnd_s
= htab
->plt_bnd
;
2572 asection
*got_s
= htab
->plt_got
;
2574 /* If this is the first .plt entry, make room for the special
2575 first entry. The .plt section is used by prelink to undo
2576 prelinking for dynamic relocations. */
2578 s
->size
= plt_entry_size
;
2581 eh
->plt_got
.offset
= got_s
->size
;
2584 h
->plt
.offset
= s
->size
;
2586 eh
->plt_bnd
.offset
= bnd_s
->size
;
2589 /* If this symbol is not defined in a regular file, and we are
2590 not generating a shared library, then set the symbol to this
2591 location in the .plt. This is required to make function
2592 pointers compare as equal between the normal executable and
2593 the shared library. */
2599 /* We need to make a call to the entry of the GOT PLT
2600 instead of regular PLT entry. */
2601 h
->root
.u
.def
.section
= got_s
;
2602 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2608 /* We need to make a call to the entry of the second
2609 PLT instead of regular PLT entry. */
2610 h
->root
.u
.def
.section
= bnd_s
;
2611 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2615 h
->root
.u
.def
.section
= s
;
2616 h
->root
.u
.def
.value
= h
->plt
.offset
;
2621 /* Make room for this entry. */
2623 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2626 s
->size
+= plt_entry_size
;
2628 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2630 /* We also need to make an entry in the .got.plt section,
2631 which will be placed in the .got section by the linker
2633 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2635 /* We also need to make an entry in the .rela.plt
2637 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2638 htab
->elf
.srelplt
->reloc_count
++;
2643 h
->plt
.offset
= (bfd_vma
) -1;
2649 h
->plt
.offset
= (bfd_vma
) -1;
2653 eh
->tlsdesc_got
= (bfd_vma
) -1;
2655 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2656 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2657 if (h
->got
.refcount
> 0
2660 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2662 h
->got
.offset
= (bfd_vma
) -1;
2664 else if (h
->got
.refcount
> 0)
2668 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2670 /* Make sure this symbol is output as a dynamic symbol.
2671 Undefined weak syms won't yet be marked as dynamic. */
2672 if (h
->dynindx
== -1
2673 && !h
->forced_local
)
2675 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2679 if (GOT_TLS_GDESC_P (tls_type
))
2681 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2682 - elf_x86_64_compute_jump_table_size (htab
);
2683 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2684 h
->got
.offset
= (bfd_vma
) -2;
2686 if (! GOT_TLS_GDESC_P (tls_type
)
2687 || GOT_TLS_GD_P (tls_type
))
2690 h
->got
.offset
= s
->size
;
2691 s
->size
+= GOT_ENTRY_SIZE
;
2692 if (GOT_TLS_GD_P (tls_type
))
2693 s
->size
+= GOT_ENTRY_SIZE
;
2695 dyn
= htab
->elf
.dynamic_sections_created
;
2696 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2698 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2699 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2700 || tls_type
== GOT_TLS_IE
)
2701 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2702 else if (GOT_TLS_GD_P (tls_type
))
2703 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2704 else if (! GOT_TLS_GDESC_P (tls_type
)
2705 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2706 || h
->root
.type
!= bfd_link_hash_undefweak
)
2708 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2709 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2710 if (GOT_TLS_GDESC_P (tls_type
))
2712 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2713 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2717 h
->got
.offset
= (bfd_vma
) -1;
2719 if (eh
->dyn_relocs
== NULL
)
2722 /* In the shared -Bsymbolic case, discard space allocated for
2723 dynamic pc-relative relocs against symbols which turn out to be
2724 defined in regular objects. For the normal shared case, discard
2725 space for pc-relative relocs that have become local due to symbol
2726 visibility changes. */
2730 /* Relocs that use pc_count are those that appear on a call
2731 insn, or certain REL relocs that can generated via assembly.
2732 We want calls to protected symbols to resolve directly to the
2733 function rather than going via the plt. If people want
2734 function pointer comparisons to work as expected then they
2735 should avoid writing weird assembly. */
2736 if (SYMBOL_CALLS_LOCAL (info
, h
))
2738 struct elf_dyn_relocs
**pp
;
2740 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2742 p
->count
-= p
->pc_count
;
2751 /* Also discard relocs on undefined weak syms with non-default
2753 if (eh
->dyn_relocs
!= NULL
)
2755 if (h
->root
.type
== bfd_link_hash_undefweak
)
2757 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2758 eh
->dyn_relocs
= NULL
;
2760 /* Make sure undefined weak symbols are output as a dynamic
2762 else if (h
->dynindx
== -1
2763 && ! h
->forced_local
2764 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2767 /* For PIE, discard space for pc-relative relocs against
2768 symbols which turn out to need copy relocs. */
2769 else if (info
->executable
2770 && (h
->needs_copy
|| eh
->needs_copy
)
2774 struct elf_dyn_relocs
**pp
;
2776 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2778 if (p
->pc_count
!= 0)
2786 else if (ELIMINATE_COPY_RELOCS
)
2788 /* For the non-shared case, discard space for relocs against
2789 symbols which turn out to need copy relocs or are not
2795 || (htab
->elf
.dynamic_sections_created
2796 && (h
->root
.type
== bfd_link_hash_undefweak
2797 || h
->root
.type
== bfd_link_hash_undefined
))))
2799 /* Make sure this symbol is output as a dynamic symbol.
2800 Undefined weak syms won't yet be marked as dynamic. */
2801 if (h
->dynindx
== -1
2802 && ! h
->forced_local
2803 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2806 /* If that succeeded, we know we'll be keeping all the
2808 if (h
->dynindx
!= -1)
2812 eh
->dyn_relocs
= NULL
;
2817 /* Finally, allocate space. */
2818 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2822 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2824 BFD_ASSERT (sreloc
!= NULL
);
2826 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2832 /* Allocate space in .plt, .got and associated reloc sections for
2833 local dynamic relocs. */
2836 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2838 struct elf_link_hash_entry
*h
2839 = (struct elf_link_hash_entry
*) *slot
;
2841 if (h
->type
!= STT_GNU_IFUNC
2845 || h
->root
.type
!= bfd_link_hash_defined
)
2848 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2851 /* Find any dynamic relocs that apply to read-only sections. */
2854 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2857 struct elf_x86_64_link_hash_entry
*eh
;
2858 struct elf_dyn_relocs
*p
;
2860 /* Skip local IFUNC symbols. */
2861 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2864 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2865 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2867 asection
*s
= p
->sec
->output_section
;
2869 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2871 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2873 info
->flags
|= DF_TEXTREL
;
2875 if ((info
->warn_shared_textrel
&& info
->shared
)
2876 || info
->error_textrel
)
2877 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2878 p
->sec
->owner
, h
->root
.root
.string
,
2881 /* Not an error, just cut short the traversal. */
2889 mov foo@GOTPCREL(%rip), %reg
2892 with the local symbol, foo. */
2895 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2896 struct bfd_link_info
*link_info
)
2898 Elf_Internal_Shdr
*symtab_hdr
;
2899 Elf_Internal_Rela
*internal_relocs
;
2900 Elf_Internal_Rela
*irel
, *irelend
;
2902 struct elf_x86_64_link_hash_table
*htab
;
2903 bfd_boolean changed_contents
;
2904 bfd_boolean changed_relocs
;
2905 bfd_signed_vma
*local_got_refcounts
;
2906 bfd_vma maxpagesize
;
2908 /* Don't even try to convert non-ELF outputs. */
2909 if (!is_elf_hash_table (link_info
->hash
))
2912 /* Nothing to do if there is no need or no output. */
2913 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2914 || sec
->need_convert_mov_to_lea
== 0
2915 || bfd_is_abs_section (sec
->output_section
))
2918 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2920 /* Load the relocations for this section. */
2921 internal_relocs
= (_bfd_elf_link_read_relocs
2922 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2923 link_info
->keep_memory
));
2924 if (internal_relocs
== NULL
)
2927 htab
= elf_x86_64_hash_table (link_info
);
2928 changed_contents
= FALSE
;
2929 changed_relocs
= FALSE
;
2930 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2931 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2933 /* Get the section contents. */
2934 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2935 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2938 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2942 irelend
= internal_relocs
+ sec
->reloc_count
;
2943 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2945 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2946 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2948 struct elf_link_hash_entry
*h
;
2954 } convert_mov_to_lea
;
2955 unsigned int opcode
;
2957 if (r_type
!= R_X86_64_GOTPCREL
)
2960 roff
= irel
->r_offset
;
2965 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
2967 /* PR ld/18591: Don't convert R_X86_64_GOTPCREL relocation if it
2968 isn't for mov instruction. */
2973 convert_mov_to_lea
= none
;
2975 /* Get the symbol referred to by the reloc. */
2976 if (r_symndx
< symtab_hdr
->sh_info
)
2978 Elf_Internal_Sym
*isym
;
2980 /* Silence older GCC warning. */
2983 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2986 symtype
= ELF_ST_TYPE (isym
->st_info
);
2988 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation and
2989 skip relocation against undefined symbols. */
2990 if (symtype
!= STT_GNU_IFUNC
&& isym
->st_shndx
!= SHN_UNDEF
)
2992 if (isym
->st_shndx
== SHN_ABS
)
2993 tsec
= bfd_abs_section_ptr
;
2994 else if (isym
->st_shndx
== SHN_COMMON
)
2995 tsec
= bfd_com_section_ptr
;
2996 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
2997 tsec
= &_bfd_elf_large_com_section
;
2999 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3001 toff
= isym
->st_value
;
3002 convert_mov_to_lea
= local
;
3007 indx
= r_symndx
- symtab_hdr
->sh_info
;
3008 h
= elf_sym_hashes (abfd
)[indx
];
3009 BFD_ASSERT (h
!= NULL
);
3011 while (h
->root
.type
== bfd_link_hash_indirect
3012 || h
->root
.type
== bfd_link_hash_warning
)
3013 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3015 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
3016 avoid optimizing _DYNAMIC since ld.so may use its link-time
3019 && h
->type
!= STT_GNU_IFUNC
3020 && h
!= htab
->elf
.hdynamic
3021 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3023 tsec
= h
->root
.u
.def
.section
;
3024 toff
= h
->root
.u
.def
.value
;
3026 convert_mov_to_lea
= global
;
3030 if (convert_mov_to_lea
== none
)
3033 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3035 /* At this stage in linking, no SEC_MERGE symbol has been
3036 adjusted, so all references to such symbols need to be
3037 passed through _bfd_merged_section_offset. (Later, in
3038 relocate_section, all SEC_MERGE symbols *except* for
3039 section symbols have been adjusted.)
3041 gas may reduce relocations against symbols in SEC_MERGE
3042 sections to a relocation against the section symbol when
3043 the original addend was zero. When the reloc is against
3044 a section symbol we should include the addend in the
3045 offset passed to _bfd_merged_section_offset, since the
3046 location of interest is the original symbol. On the
3047 other hand, an access to "sym+addend" where "sym" is not
3048 a section symbol should not include the addend; Such an
3049 access is presumed to be an offset from "sym"; The
3050 location of interest is just "sym". */
3051 if (symtype
== STT_SECTION
)
3052 toff
+= irel
->r_addend
;
3054 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3055 elf_section_data (tsec
)->sec_info
,
3058 if (symtype
!= STT_SECTION
)
3059 toff
+= irel
->r_addend
;
3062 toff
+= irel
->r_addend
;
3064 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3065 if (tsec
->output_section
== sec
->output_section
)
3067 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3075 /* At this point, we don't know the load addresses of TSEC
3076 section nor SEC section. We estimate the distrance between
3079 for (asect
= sec
->output_section
;
3080 asect
!= NULL
&& asect
!= tsec
->output_section
;
3081 asect
= asect
->next
)
3084 for (i
= asect
->output_section
->map_head
.s
;
3088 size
= align_power (size
, i
->alignment_power
);
3093 /* Don't convert R_X86_64_GOTPCREL if TSEC isn't placed after
3098 /* Take PT_GNU_RELRO segment into account by adding
3100 if ((toff
+ size
+ maxpagesize
- roff
+ 0x80000000)
3105 bfd_put_8 (abfd
, 0x8d, contents
+ roff
- 2);
3106 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
3107 changed_contents
= TRUE
;
3108 changed_relocs
= TRUE
;
3110 if (convert_mov_to_lea
== local
)
3112 if (local_got_refcounts
!= NULL
3113 && local_got_refcounts
[r_symndx
] > 0)
3114 local_got_refcounts
[r_symndx
] -= 1;
3118 if (h
->got
.refcount
> 0)
3119 h
->got
.refcount
-= 1;
3123 if (contents
!= NULL
3124 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3126 if (!changed_contents
&& !link_info
->keep_memory
)
3130 /* Cache the section contents for elf_link_input_bfd. */
3131 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3135 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3137 if (!changed_relocs
)
3138 free (internal_relocs
);
3140 elf_section_data (sec
)->relocs
= internal_relocs
;
3146 if (contents
!= NULL
3147 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3149 if (internal_relocs
!= NULL
3150 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3151 free (internal_relocs
);
3155 /* Set the sizes of the dynamic sections. */
3158 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3159 struct bfd_link_info
*info
)
3161 struct elf_x86_64_link_hash_table
*htab
;
3166 const struct elf_backend_data
*bed
;
3168 htab
= elf_x86_64_hash_table (info
);
3171 bed
= get_elf_backend_data (output_bfd
);
3173 dynobj
= htab
->elf
.dynobj
;
3177 if (htab
->elf
.dynamic_sections_created
)
3179 /* Set the contents of the .interp section to the interpreter. */
3180 if (info
->executable
)
3182 s
= bfd_get_linker_section (dynobj
, ".interp");
3185 s
->size
= htab
->dynamic_interpreter_size
;
3186 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3190 /* Set up .got offsets for local syms, and space for local dynamic
3192 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3194 bfd_signed_vma
*local_got
;
3195 bfd_signed_vma
*end_local_got
;
3196 char *local_tls_type
;
3197 bfd_vma
*local_tlsdesc_gotent
;
3198 bfd_size_type locsymcount
;
3199 Elf_Internal_Shdr
*symtab_hdr
;
3202 if (! is_x86_64_elf (ibfd
))
3205 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3207 struct elf_dyn_relocs
*p
;
3209 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
3212 for (p
= (struct elf_dyn_relocs
*)
3213 (elf_section_data (s
)->local_dynrel
);
3217 if (!bfd_is_abs_section (p
->sec
)
3218 && bfd_is_abs_section (p
->sec
->output_section
))
3220 /* Input section has been discarded, either because
3221 it is a copy of a linkonce section or due to
3222 linker script /DISCARD/, so we'll be discarding
3225 else if (p
->count
!= 0)
3227 srel
= elf_section_data (p
->sec
)->sreloc
;
3228 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3229 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3230 && (info
->flags
& DF_TEXTREL
) == 0)
3232 info
->flags
|= DF_TEXTREL
;
3233 if ((info
->warn_shared_textrel
&& info
->shared
)
3234 || info
->error_textrel
)
3235 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3236 p
->sec
->owner
, p
->sec
);
3242 local_got
= elf_local_got_refcounts (ibfd
);
3246 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3247 locsymcount
= symtab_hdr
->sh_info
;
3248 end_local_got
= local_got
+ locsymcount
;
3249 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3250 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3252 srel
= htab
->elf
.srelgot
;
3253 for (; local_got
< end_local_got
;
3254 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3256 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3259 if (GOT_TLS_GDESC_P (*local_tls_type
))
3261 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3262 - elf_x86_64_compute_jump_table_size (htab
);
3263 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3264 *local_got
= (bfd_vma
) -2;
3266 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3267 || GOT_TLS_GD_P (*local_tls_type
))
3269 *local_got
= s
->size
;
3270 s
->size
+= GOT_ENTRY_SIZE
;
3271 if (GOT_TLS_GD_P (*local_tls_type
))
3272 s
->size
+= GOT_ENTRY_SIZE
;
3275 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3276 || *local_tls_type
== GOT_TLS_IE
)
3278 if (GOT_TLS_GDESC_P (*local_tls_type
))
3280 htab
->elf
.srelplt
->size
3281 += bed
->s
->sizeof_rela
;
3282 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3284 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3285 || GOT_TLS_GD_P (*local_tls_type
))
3286 srel
->size
+= bed
->s
->sizeof_rela
;
3290 *local_got
= (bfd_vma
) -1;
3294 if (htab
->tls_ld_got
.refcount
> 0)
3296 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3298 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3299 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3300 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3303 htab
->tls_ld_got
.offset
= -1;
3305 /* Allocate global sym .plt and .got entries, and space for global
3306 sym dynamic relocs. */
3307 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3310 /* Allocate .plt and .got entries, and space for local symbols. */
3311 htab_traverse (htab
->loc_hash_table
,
3312 elf_x86_64_allocate_local_dynrelocs
,
3315 /* For every jump slot reserved in the sgotplt, reloc_count is
3316 incremented. However, when we reserve space for TLS descriptors,
3317 it's not incremented, so in order to compute the space reserved
3318 for them, it suffices to multiply the reloc count by the jump
3321 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3322 so that R_X86_64_IRELATIVE entries come last. */
3323 if (htab
->elf
.srelplt
)
3325 htab
->sgotplt_jump_table_size
3326 = elf_x86_64_compute_jump_table_size (htab
);
3327 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3329 else if (htab
->elf
.irelplt
)
3330 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3332 if (htab
->tlsdesc_plt
)
3334 /* If we're not using lazy TLS relocations, don't generate the
3335 PLT and GOT entries they require. */
3336 if ((info
->flags
& DF_BIND_NOW
))
3337 htab
->tlsdesc_plt
= 0;
3340 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3341 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3342 /* Reserve room for the initial entry.
3343 FIXME: we could probably do away with it in this case. */
3344 if (htab
->elf
.splt
->size
== 0)
3345 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3346 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3347 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3351 if (htab
->elf
.sgotplt
)
3353 /* Don't allocate .got.plt section if there are no GOT nor PLT
3354 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3355 if ((htab
->elf
.hgot
== NULL
3356 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3357 && (htab
->elf
.sgotplt
->size
3358 == get_elf_backend_data (output_bfd
)->got_header_size
)
3359 && (htab
->elf
.splt
== NULL
3360 || htab
->elf
.splt
->size
== 0)
3361 && (htab
->elf
.sgot
== NULL
3362 || htab
->elf
.sgot
->size
== 0)
3363 && (htab
->elf
.iplt
== NULL
3364 || htab
->elf
.iplt
->size
== 0)
3365 && (htab
->elf
.igotplt
== NULL
3366 || htab
->elf
.igotplt
->size
== 0))
3367 htab
->elf
.sgotplt
->size
= 0;
3370 if (htab
->plt_eh_frame
!= NULL
3371 && htab
->elf
.splt
!= NULL
3372 && htab
->elf
.splt
->size
!= 0
3373 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3374 && _bfd_elf_eh_frame_present (info
))
3376 const struct elf_x86_64_backend_data
*arch_data
3377 = get_elf_x86_64_arch_data (bed
);
3378 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3381 /* We now have determined the sizes of the various dynamic sections.
3382 Allocate memory for them. */
3384 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3386 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3389 if (s
== htab
->elf
.splt
3390 || s
== htab
->elf
.sgot
3391 || s
== htab
->elf
.sgotplt
3392 || s
== htab
->elf
.iplt
3393 || s
== htab
->elf
.igotplt
3394 || s
== htab
->plt_bnd
3395 || s
== htab
->plt_got
3396 || s
== htab
->plt_eh_frame
3397 || s
== htab
->sdynbss
)
3399 /* Strip this section if we don't need it; see the
3402 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3404 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3407 /* We use the reloc_count field as a counter if we need
3408 to copy relocs into the output file. */
3409 if (s
!= htab
->elf
.srelplt
)
3414 /* It's not one of our sections, so don't allocate space. */
3420 /* If we don't need this section, strip it from the
3421 output file. This is mostly to handle .rela.bss and
3422 .rela.plt. We must create both sections in
3423 create_dynamic_sections, because they must be created
3424 before the linker maps input sections to output
3425 sections. The linker does that before
3426 adjust_dynamic_symbol is called, and it is that
3427 function which decides whether anything needs to go
3428 into these sections. */
3430 s
->flags
|= SEC_EXCLUDE
;
3434 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3437 /* Allocate memory for the section contents. We use bfd_zalloc
3438 here in case unused entries are not reclaimed before the
3439 section's contents are written out. This should not happen,
3440 but this way if it does, we get a R_X86_64_NONE reloc instead
3442 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3443 if (s
->contents
== NULL
)
3447 if (htab
->plt_eh_frame
!= NULL
3448 && htab
->plt_eh_frame
->contents
!= NULL
)
3450 const struct elf_x86_64_backend_data
*arch_data
3451 = get_elf_x86_64_arch_data (bed
);
3453 memcpy (htab
->plt_eh_frame
->contents
,
3454 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3455 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3456 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3459 if (htab
->elf
.dynamic_sections_created
)
3461 /* Add some entries to the .dynamic section. We fill in the
3462 values later, in elf_x86_64_finish_dynamic_sections, but we
3463 must add the entries now so that we get the correct size for
3464 the .dynamic section. The DT_DEBUG entry is filled in by the
3465 dynamic linker and used by the debugger. */
3466 #define add_dynamic_entry(TAG, VAL) \
3467 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3469 if (info
->executable
)
3471 if (!add_dynamic_entry (DT_DEBUG
, 0))
3475 if (htab
->elf
.splt
->size
!= 0)
3477 /* DT_PLTGOT is used by prelink even if there is no PLT
3479 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3482 if (htab
->elf
.srelplt
->size
!= 0)
3484 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3485 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3486 || !add_dynamic_entry (DT_JMPREL
, 0))
3490 if (htab
->tlsdesc_plt
3491 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3492 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3498 if (!add_dynamic_entry (DT_RELA
, 0)
3499 || !add_dynamic_entry (DT_RELASZ
, 0)
3500 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3503 /* If any dynamic relocs apply to a read-only section,
3504 then we need a DT_TEXTREL entry. */
3505 if ((info
->flags
& DF_TEXTREL
) == 0)
3506 elf_link_hash_traverse (&htab
->elf
,
3507 elf_x86_64_readonly_dynrelocs
,
3510 if ((info
->flags
& DF_TEXTREL
) != 0)
3512 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3517 #undef add_dynamic_entry
3523 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3524 struct bfd_link_info
*info
)
3526 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3530 struct elf_link_hash_entry
*tlsbase
;
3532 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3533 "_TLS_MODULE_BASE_",
3534 FALSE
, FALSE
, FALSE
);
3536 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3538 struct elf_x86_64_link_hash_table
*htab
;
3539 struct bfd_link_hash_entry
*bh
= NULL
;
3540 const struct elf_backend_data
*bed
3541 = get_elf_backend_data (output_bfd
);
3543 htab
= elf_x86_64_hash_table (info
);
3547 if (!(_bfd_generic_link_add_one_symbol
3548 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3549 tls_sec
, 0, NULL
, FALSE
,
3550 bed
->collect
, &bh
)))
3553 htab
->tls_module_base
= bh
;
3555 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3556 tlsbase
->def_regular
= 1;
3557 tlsbase
->other
= STV_HIDDEN
;
3558 tlsbase
->root
.linker_def
= 1;
3559 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3566 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3567 executables. Rather than setting it to the beginning of the TLS
3568 section, we have to set it to the end. This function may be called
3569 multiple times, it is idempotent. */
3572 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3574 struct elf_x86_64_link_hash_table
*htab
;
3575 struct bfd_link_hash_entry
*base
;
3577 if (!info
->executable
)
3580 htab
= elf_x86_64_hash_table (info
);
3584 base
= htab
->tls_module_base
;
3588 base
->u
.def
.value
= htab
->elf
.tls_size
;
3591 /* Return the base VMA address which should be subtracted from real addresses
3592 when resolving @dtpoff relocation.
3593 This is PT_TLS segment p_vaddr. */
3596 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3598 /* If tls_sec is NULL, we should have signalled an error already. */
3599 if (elf_hash_table (info
)->tls_sec
== NULL
)
3601 return elf_hash_table (info
)->tls_sec
->vma
;
3604 /* Return the relocation value for @tpoff relocation
3605 if STT_TLS virtual address is ADDRESS. */
3608 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3610 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3611 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3612 bfd_vma static_tls_size
;
3614 /* If tls_segment is NULL, we should have signalled an error already. */
3615 if (htab
->tls_sec
== NULL
)
3618 /* Consider special static TLS alignment requirements. */
3619 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3620 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3623 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3627 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3629 /* Opcode Instruction
3632 0x0f 0x8x conditional jump */
3634 && (contents
[offset
- 1] == 0xe8
3635 || contents
[offset
- 1] == 0xe9))
3637 && contents
[offset
- 2] == 0x0f
3638 && (contents
[offset
- 1] & 0xf0) == 0x80));
3641 /* Relocate an x86_64 ELF section. */
3644 elf_x86_64_relocate_section (bfd
*output_bfd
,
3645 struct bfd_link_info
*info
,
3647 asection
*input_section
,
3649 Elf_Internal_Rela
*relocs
,
3650 Elf_Internal_Sym
*local_syms
,
3651 asection
**local_sections
)
3653 struct elf_x86_64_link_hash_table
*htab
;
3654 Elf_Internal_Shdr
*symtab_hdr
;
3655 struct elf_link_hash_entry
**sym_hashes
;
3656 bfd_vma
*local_got_offsets
;
3657 bfd_vma
*local_tlsdesc_gotents
;
3658 Elf_Internal_Rela
*rel
;
3659 Elf_Internal_Rela
*relend
;
3660 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3662 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3664 htab
= elf_x86_64_hash_table (info
);
3667 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3668 sym_hashes
= elf_sym_hashes (input_bfd
);
3669 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3670 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3672 elf_x86_64_set_tls_module_base (info
);
3675 relend
= relocs
+ input_section
->reloc_count
;
3676 for (; rel
< relend
; rel
++)
3678 unsigned int r_type
;
3679 reloc_howto_type
*howto
;
3680 unsigned long r_symndx
;
3681 struct elf_link_hash_entry
*h
;
3682 struct elf_x86_64_link_hash_entry
*eh
;
3683 Elf_Internal_Sym
*sym
;
3685 bfd_vma off
, offplt
, plt_offset
;
3687 bfd_boolean unresolved_reloc
;
3688 bfd_reloc_status_type r
;
3690 asection
*base_got
, *resolved_plt
;
3693 r_type
= ELF32_R_TYPE (rel
->r_info
);
3694 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3695 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3698 if (r_type
>= (int) R_X86_64_standard
)
3700 (*_bfd_error_handler
)
3701 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3702 input_bfd
, input_section
, r_type
);
3703 bfd_set_error (bfd_error_bad_value
);
3707 if (r_type
!= (int) R_X86_64_32
3708 || ABI_64_P (output_bfd
))
3709 howto
= x86_64_elf_howto_table
+ r_type
;
3711 howto
= (x86_64_elf_howto_table
3712 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3713 r_symndx
= htab
->r_sym (rel
->r_info
);
3717 unresolved_reloc
= FALSE
;
3718 if (r_symndx
< symtab_hdr
->sh_info
)
3720 sym
= local_syms
+ r_symndx
;
3721 sec
= local_sections
[r_symndx
];
3723 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3725 st_size
= sym
->st_size
;
3727 /* Relocate against local STT_GNU_IFUNC symbol. */
3728 if (!info
->relocatable
3729 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3731 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3736 /* Set STT_GNU_IFUNC symbol value. */
3737 h
->root
.u
.def
.value
= sym
->st_value
;
3738 h
->root
.u
.def
.section
= sec
;
3743 bfd_boolean warned ATTRIBUTE_UNUSED
;
3744 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3746 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3747 r_symndx
, symtab_hdr
, sym_hashes
,
3749 unresolved_reloc
, warned
, ignored
);
3753 if (sec
!= NULL
&& discarded_section (sec
))
3754 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3755 rel
, 1, relend
, howto
, 0, contents
);
3757 if (info
->relocatable
)
3760 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3762 if (r_type
== R_X86_64_64
)
3764 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3765 zero-extend it to 64bit if addend is zero. */
3766 r_type
= R_X86_64_32
;
3767 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3769 else if (r_type
== R_X86_64_SIZE64
)
3771 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3772 zero-extend it to 64bit if addend is zero. */
3773 r_type
= R_X86_64_SIZE32
;
3774 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3778 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3780 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3781 it here if it is defined in a non-shared object. */
3783 && h
->type
== STT_GNU_IFUNC
3789 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3791 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3792 sections because such sections are not SEC_ALLOC and
3793 thus ld.so will not process them. */
3794 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3798 else if (h
->plt
.offset
== (bfd_vma
) -1)
3801 /* STT_GNU_IFUNC symbol must go through PLT. */
3802 if (htab
->elf
.splt
!= NULL
)
3804 if (htab
->plt_bnd
!= NULL
)
3806 resolved_plt
= htab
->plt_bnd
;
3807 plt_offset
= eh
->plt_bnd
.offset
;
3811 resolved_plt
= htab
->elf
.splt
;
3812 plt_offset
= h
->plt
.offset
;
3817 resolved_plt
= htab
->elf
.iplt
;
3818 plt_offset
= h
->plt
.offset
;
3821 relocation
= (resolved_plt
->output_section
->vma
3822 + resolved_plt
->output_offset
+ plt_offset
);
3827 if (h
->root
.root
.string
)
3828 name
= h
->root
.root
.string
;
3830 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3832 (*_bfd_error_handler
)
3833 (_("%B: relocation %s against STT_GNU_IFUNC "
3834 "symbol `%s' isn't handled by %s"), input_bfd
,
3835 x86_64_elf_howto_table
[r_type
].name
,
3836 name
, __FUNCTION__
);
3837 bfd_set_error (bfd_error_bad_value
);
3846 if (ABI_64_P (output_bfd
))
3850 if (rel
->r_addend
!= 0)
3852 if (h
->root
.root
.string
)
3853 name
= h
->root
.root
.string
;
3855 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3857 (*_bfd_error_handler
)
3858 (_("%B: relocation %s against STT_GNU_IFUNC "
3859 "symbol `%s' has non-zero addend: %d"),
3860 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3861 name
, rel
->r_addend
);
3862 bfd_set_error (bfd_error_bad_value
);
3866 /* Generate dynamic relcoation only when there is a
3867 non-GOT reference in a shared object. */
3868 if (info
->shared
&& h
->non_got_ref
)
3870 Elf_Internal_Rela outrel
;
3873 /* Need a dynamic relocation to get the real function
3875 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3879 if (outrel
.r_offset
== (bfd_vma
) -1
3880 || outrel
.r_offset
== (bfd_vma
) -2)
3883 outrel
.r_offset
+= (input_section
->output_section
->vma
3884 + input_section
->output_offset
);
3886 if (h
->dynindx
== -1
3888 || info
->executable
)
3890 /* This symbol is resolved locally. */
3891 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3892 outrel
.r_addend
= (h
->root
.u
.def
.value
3893 + h
->root
.u
.def
.section
->output_section
->vma
3894 + h
->root
.u
.def
.section
->output_offset
);
3898 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3899 outrel
.r_addend
= 0;
3902 sreloc
= htab
->elf
.irelifunc
;
3903 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3905 /* If this reloc is against an external symbol, we
3906 do not want to fiddle with the addend. Otherwise,
3907 we need to include the symbol value so that it
3908 becomes an addend for the dynamic reloc. For an
3909 internal symbol, we have updated addend. */
3914 case R_X86_64_PC32_BND
:
3916 case R_X86_64_PLT32
:
3917 case R_X86_64_PLT32_BND
:
3920 case R_X86_64_GOTPCREL
:
3921 case R_X86_64_GOTPCREL64
:
3922 base_got
= htab
->elf
.sgot
;
3923 off
= h
->got
.offset
;
3925 if (base_got
== NULL
)
3928 if (off
== (bfd_vma
) -1)
3930 /* We can't use h->got.offset here to save state, or
3931 even just remember the offset, as finish_dynamic_symbol
3932 would use that as offset into .got. */
3934 if (htab
->elf
.splt
!= NULL
)
3936 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3937 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3938 base_got
= htab
->elf
.sgotplt
;
3942 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3943 off
= plt_index
* GOT_ENTRY_SIZE
;
3944 base_got
= htab
->elf
.igotplt
;
3947 if (h
->dynindx
== -1
3951 /* This references the local defitionion. We must
3952 initialize this entry in the global offset table.
3953 Since the offset must always be a multiple of 8,
3954 we use the least significant bit to record
3955 whether we have initialized it already.
3957 When doing a dynamic link, we create a .rela.got
3958 relocation entry to initialize the value. This
3959 is done in the finish_dynamic_symbol routine. */
3964 bfd_put_64 (output_bfd
, relocation
,
3965 base_got
->contents
+ off
);
3966 /* Note that this is harmless for the GOTPLT64
3967 case, as -1 | 1 still is -1. */
3973 relocation
= (base_got
->output_section
->vma
3974 + base_got
->output_offset
+ off
);
3980 /* When generating a shared object, the relocations handled here are
3981 copied into the output file to be resolved at run time. */
3984 case R_X86_64_GOT32
:
3985 case R_X86_64_GOT64
:
3986 /* Relocation is to the entry for this symbol in the global
3988 case R_X86_64_GOTPCREL
:
3989 case R_X86_64_GOTPCREL64
:
3990 /* Use global offset table entry as symbol value. */
3991 case R_X86_64_GOTPLT64
:
3992 /* This is obsolete and treated the the same as GOT64. */
3993 base_got
= htab
->elf
.sgot
;
3995 if (htab
->elf
.sgot
== NULL
)
4002 off
= h
->got
.offset
;
4004 && h
->plt
.offset
!= (bfd_vma
)-1
4005 && off
== (bfd_vma
)-1)
4007 /* We can't use h->got.offset here to save
4008 state, or even just remember the offset, as
4009 finish_dynamic_symbol would use that as offset into
4011 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4012 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4013 base_got
= htab
->elf
.sgotplt
;
4016 dyn
= htab
->elf
.dynamic_sections_created
;
4018 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
4020 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4021 || (ELF_ST_VISIBILITY (h
->other
)
4022 && h
->root
.type
== bfd_link_hash_undefweak
))
4024 /* This is actually a static link, or it is a -Bsymbolic
4025 link and the symbol is defined locally, or the symbol
4026 was forced to be local because of a version file. We
4027 must initialize this entry in the global offset table.
4028 Since the offset must always be a multiple of 8, we
4029 use the least significant bit to record whether we
4030 have initialized it already.
4032 When doing a dynamic link, we create a .rela.got
4033 relocation entry to initialize the value. This is
4034 done in the finish_dynamic_symbol routine. */
4039 bfd_put_64 (output_bfd
, relocation
,
4040 base_got
->contents
+ off
);
4041 /* Note that this is harmless for the GOTPLT64 case,
4042 as -1 | 1 still is -1. */
4047 unresolved_reloc
= FALSE
;
4051 if (local_got_offsets
== NULL
)
4054 off
= local_got_offsets
[r_symndx
];
4056 /* The offset must always be a multiple of 8. We use
4057 the least significant bit to record whether we have
4058 already generated the necessary reloc. */
4063 bfd_put_64 (output_bfd
, relocation
,
4064 base_got
->contents
+ off
);
4069 Elf_Internal_Rela outrel
;
4071 /* We need to generate a R_X86_64_RELATIVE reloc
4072 for the dynamic linker. */
4073 s
= htab
->elf
.srelgot
;
4077 outrel
.r_offset
= (base_got
->output_section
->vma
4078 + base_got
->output_offset
4080 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4081 outrel
.r_addend
= relocation
;
4082 elf_append_rela (output_bfd
, s
, &outrel
);
4085 local_got_offsets
[r_symndx
] |= 1;
4089 if (off
>= (bfd_vma
) -2)
4092 relocation
= base_got
->output_section
->vma
4093 + base_got
->output_offset
+ off
;
4094 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
4095 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4096 - htab
->elf
.sgotplt
->output_offset
;
4100 case R_X86_64_GOTOFF64
:
4101 /* Relocation is relative to the start of the global offset
4104 /* Check to make sure it isn't a protected function or data
4105 symbol for shared library since it may not be local when
4106 used as function address or with copy relocation. We also
4107 need to make sure that a symbol is referenced locally. */
4108 if (info
->shared
&& h
)
4110 if (!h
->def_regular
)
4114 switch (ELF_ST_VISIBILITY (h
->other
))
4117 v
= _("hidden symbol");
4120 v
= _("internal symbol");
4123 v
= _("protected symbol");
4130 (*_bfd_error_handler
)
4131 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4132 input_bfd
, v
, h
->root
.root
.string
);
4133 bfd_set_error (bfd_error_bad_value
);
4136 else if (!info
->executable
4137 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4138 && (h
->type
== STT_FUNC
4139 || h
->type
== STT_OBJECT
)
4140 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4142 (*_bfd_error_handler
)
4143 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4145 h
->type
== STT_FUNC
? "function" : "data",
4146 h
->root
.root
.string
);
4147 bfd_set_error (bfd_error_bad_value
);
4152 /* Note that sgot is not involved in this
4153 calculation. We always want the start of .got.plt. If we
4154 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4155 permitted by the ABI, we might have to change this
4157 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4158 + htab
->elf
.sgotplt
->output_offset
;
4161 case R_X86_64_GOTPC32
:
4162 case R_X86_64_GOTPC64
:
4163 /* Use global offset table as symbol value. */
4164 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4165 + htab
->elf
.sgotplt
->output_offset
;
4166 unresolved_reloc
= FALSE
;
4169 case R_X86_64_PLTOFF64
:
4170 /* Relocation is PLT entry relative to GOT. For local
4171 symbols it's the symbol itself relative to GOT. */
4173 /* See PLT32 handling. */
4174 && h
->plt
.offset
!= (bfd_vma
) -1
4175 && htab
->elf
.splt
!= NULL
)
4177 if (htab
->plt_bnd
!= NULL
)
4179 resolved_plt
= htab
->plt_bnd
;
4180 plt_offset
= eh
->plt_bnd
.offset
;
4184 resolved_plt
= htab
->elf
.splt
;
4185 plt_offset
= h
->plt
.offset
;
4188 relocation
= (resolved_plt
->output_section
->vma
4189 + resolved_plt
->output_offset
4191 unresolved_reloc
= FALSE
;
4194 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4195 + htab
->elf
.sgotplt
->output_offset
;
4198 case R_X86_64_PLT32
:
4199 case R_X86_64_PLT32_BND
:
4200 /* Relocation is to the entry for this symbol in the
4201 procedure linkage table. */
4203 /* Resolve a PLT32 reloc against a local symbol directly,
4204 without using the procedure linkage table. */
4208 if ((h
->plt
.offset
== (bfd_vma
) -1
4209 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4210 || htab
->elf
.splt
== NULL
)
4212 /* We didn't make a PLT entry for this symbol. This
4213 happens when statically linking PIC code, or when
4214 using -Bsymbolic. */
4218 if (h
->plt
.offset
!= (bfd_vma
) -1)
4220 if (htab
->plt_bnd
!= NULL
)
4222 resolved_plt
= htab
->plt_bnd
;
4223 plt_offset
= eh
->plt_bnd
.offset
;
4227 resolved_plt
= htab
->elf
.splt
;
4228 plt_offset
= h
->plt
.offset
;
4233 /* Use the GOT PLT. */
4234 resolved_plt
= htab
->plt_got
;
4235 plt_offset
= eh
->plt_got
.offset
;
4238 relocation
= (resolved_plt
->output_section
->vma
4239 + resolved_plt
->output_offset
4241 unresolved_reloc
= FALSE
;
4244 case R_X86_64_SIZE32
:
4245 case R_X86_64_SIZE64
:
4246 /* Set to symbol size. */
4247 relocation
= st_size
;
4253 case R_X86_64_PC32_BND
:
4254 /* Don't complain about -fPIC if the symbol is undefined when
4255 building executable. */
4257 && (input_section
->flags
& SEC_ALLOC
) != 0
4258 && (input_section
->flags
& SEC_READONLY
) != 0
4260 && !(info
->executable
4261 && h
->root
.type
== bfd_link_hash_undefined
))
4263 bfd_boolean fail
= FALSE
;
4265 = ((r_type
== R_X86_64_PC32
4266 || r_type
== R_X86_64_PC32_BND
)
4267 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4269 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4271 /* Symbol is referenced locally. Make sure it is
4272 defined locally or for a branch. */
4273 fail
= !h
->def_regular
&& !branch
;
4275 else if (!(info
->executable
4276 && (h
->needs_copy
|| eh
->needs_copy
)))
4278 /* Symbol doesn't need copy reloc and isn't referenced
4279 locally. We only allow branch to symbol with
4280 non-default visibility. */
4282 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4289 const char *pic
= "";
4291 switch (ELF_ST_VISIBILITY (h
->other
))
4294 v
= _("hidden symbol");
4297 v
= _("internal symbol");
4300 v
= _("protected symbol");
4304 pic
= _("; recompile with -fPIC");
4309 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4311 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4313 (*_bfd_error_handler
) (fmt
, input_bfd
,
4314 x86_64_elf_howto_table
[r_type
].name
,
4315 v
, h
->root
.root
.string
, pic
);
4316 bfd_set_error (bfd_error_bad_value
);
4327 /* FIXME: The ABI says the linker should make sure the value is
4328 the same when it's zeroextended to 64 bit. */
4331 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4334 /* Don't copy a pc-relative relocation into the output file
4335 if the symbol needs copy reloc or the symbol is undefined
4336 when building executable. */
4338 && !(info
->executable
4342 || h
->root
.type
== bfd_link_hash_undefined
)
4343 && IS_X86_64_PCREL_TYPE (r_type
))
4345 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4346 || h
->root
.type
!= bfd_link_hash_undefweak
)
4347 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4348 && r_type
!= R_X86_64_SIZE32
4349 && r_type
!= R_X86_64_SIZE64
)
4350 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4351 || (ELIMINATE_COPY_RELOCS
4358 || h
->root
.type
== bfd_link_hash_undefweak
4359 || h
->root
.type
== bfd_link_hash_undefined
)))
4361 Elf_Internal_Rela outrel
;
4362 bfd_boolean skip
, relocate
;
4365 /* When generating a shared object, these relocations
4366 are copied into the output file to be resolved at run
4372 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4374 if (outrel
.r_offset
== (bfd_vma
) -1)
4376 else if (outrel
.r_offset
== (bfd_vma
) -2)
4377 skip
= TRUE
, relocate
= TRUE
;
4379 outrel
.r_offset
+= (input_section
->output_section
->vma
4380 + input_section
->output_offset
);
4383 memset (&outrel
, 0, sizeof outrel
);
4385 /* h->dynindx may be -1 if this symbol was marked to
4389 && (IS_X86_64_PCREL_TYPE (r_type
)
4391 || ! SYMBOLIC_BIND (info
, h
)
4392 || ! h
->def_regular
))
4394 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4395 outrel
.r_addend
= rel
->r_addend
;
4399 /* This symbol is local, or marked to become local. */
4400 if (r_type
== htab
->pointer_r_type
)
4403 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4404 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4406 else if (r_type
== R_X86_64_64
4407 && !ABI_64_P (output_bfd
))
4410 outrel
.r_info
= htab
->r_info (0,
4411 R_X86_64_RELATIVE64
);
4412 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4413 /* Check addend overflow. */
4414 if ((outrel
.r_addend
& 0x80000000)
4415 != (rel
->r_addend
& 0x80000000))
4418 int addend
= rel
->r_addend
;
4419 if (h
&& h
->root
.root
.string
)
4420 name
= h
->root
.root
.string
;
4422 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4425 (*_bfd_error_handler
)
4426 (_("%B: addend -0x%x in relocation %s against "
4427 "symbol `%s' at 0x%lx in section `%A' is "
4429 input_bfd
, input_section
, addend
,
4430 x86_64_elf_howto_table
[r_type
].name
,
4431 name
, (unsigned long) rel
->r_offset
);
4433 (*_bfd_error_handler
)
4434 (_("%B: addend 0x%x in relocation %s against "
4435 "symbol `%s' at 0x%lx in section `%A' is "
4437 input_bfd
, input_section
, addend
,
4438 x86_64_elf_howto_table
[r_type
].name
,
4439 name
, (unsigned long) rel
->r_offset
);
4440 bfd_set_error (bfd_error_bad_value
);
4448 if (bfd_is_abs_section (sec
))
4450 else if (sec
== NULL
|| sec
->owner
== NULL
)
4452 bfd_set_error (bfd_error_bad_value
);
4459 /* We are turning this relocation into one
4460 against a section symbol. It would be
4461 proper to subtract the symbol's value,
4462 osec->vma, from the emitted reloc addend,
4463 but ld.so expects buggy relocs. */
4464 osec
= sec
->output_section
;
4465 sindx
= elf_section_data (osec
)->dynindx
;
4468 asection
*oi
= htab
->elf
.text_index_section
;
4469 sindx
= elf_section_data (oi
)->dynindx
;
4471 BFD_ASSERT (sindx
!= 0);
4474 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4475 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4479 sreloc
= elf_section_data (input_section
)->sreloc
;
4481 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4483 r
= bfd_reloc_notsupported
;
4484 goto check_relocation_error
;
4487 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4489 /* If this reloc is against an external symbol, we do
4490 not want to fiddle with the addend. Otherwise, we
4491 need to include the symbol value so that it becomes
4492 an addend for the dynamic reloc. */
4499 case R_X86_64_TLSGD
:
4500 case R_X86_64_GOTPC32_TLSDESC
:
4501 case R_X86_64_TLSDESC_CALL
:
4502 case R_X86_64_GOTTPOFF
:
4503 tls_type
= GOT_UNKNOWN
;
4504 if (h
== NULL
&& local_got_offsets
)
4505 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4507 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4509 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4510 input_section
, contents
,
4511 symtab_hdr
, sym_hashes
,
4512 &r_type
, tls_type
, rel
,
4513 relend
, h
, r_symndx
))
4516 if (r_type
== R_X86_64_TPOFF32
)
4518 bfd_vma roff
= rel
->r_offset
;
4520 BFD_ASSERT (! unresolved_reloc
);
4522 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4524 /* GD->LE transition. For 64bit, change
4525 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4526 .word 0x6666; rex64; call __tls_get_addr
4529 leaq foo@tpoff(%rax), %rax
4531 leaq foo@tlsgd(%rip), %rdi
4532 .word 0x6666; rex64; call __tls_get_addr
4535 leaq foo@tpoff(%rax), %rax
4536 For largepic, change:
4537 leaq foo@tlsgd(%rip), %rdi
4538 movabsq $__tls_get_addr@pltoff, %rax
4543 leaq foo@tpoff(%rax), %rax
4544 nopw 0x0(%rax,%rax,1) */
4546 if (ABI_64_P (output_bfd
)
4547 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4549 memcpy (contents
+ roff
- 3,
4550 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4551 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4554 else if (ABI_64_P (output_bfd
))
4555 memcpy (contents
+ roff
- 4,
4556 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4559 memcpy (contents
+ roff
- 3,
4560 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4562 bfd_put_32 (output_bfd
,
4563 elf_x86_64_tpoff (info
, relocation
),
4564 contents
+ roff
+ 8 + largepic
);
4565 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4569 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4571 /* GDesc -> LE transition.
4572 It's originally something like:
4573 leaq x@tlsdesc(%rip), %rax
4576 movl $x@tpoff, %rax. */
4578 unsigned int val
, type
;
4580 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4581 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4582 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4583 contents
+ roff
- 3);
4584 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4585 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4586 contents
+ roff
- 1);
4587 bfd_put_32 (output_bfd
,
4588 elf_x86_64_tpoff (info
, relocation
),
4592 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4594 /* GDesc -> LE transition.
4599 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4600 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4603 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4605 /* IE->LE transition:
4606 For 64bit, originally it can be one of:
4607 movq foo@gottpoff(%rip), %reg
4608 addq foo@gottpoff(%rip), %reg
4611 leaq foo(%reg), %reg
4613 For 32bit, originally it can be one of:
4614 movq foo@gottpoff(%rip), %reg
4615 addl foo@gottpoff(%rip), %reg
4618 leal foo(%reg), %reg
4621 unsigned int val
, type
, reg
;
4624 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4627 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4628 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4634 bfd_put_8 (output_bfd
, 0x49,
4635 contents
+ roff
- 3);
4636 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4637 bfd_put_8 (output_bfd
, 0x41,
4638 contents
+ roff
- 3);
4639 bfd_put_8 (output_bfd
, 0xc7,
4640 contents
+ roff
- 2);
4641 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4642 contents
+ roff
- 1);
4646 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4649 bfd_put_8 (output_bfd
, 0x49,
4650 contents
+ roff
- 3);
4651 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4652 bfd_put_8 (output_bfd
, 0x41,
4653 contents
+ roff
- 3);
4654 bfd_put_8 (output_bfd
, 0x81,
4655 contents
+ roff
- 2);
4656 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4657 contents
+ roff
- 1);
4661 /* addq/addl -> leaq/leal */
4663 bfd_put_8 (output_bfd
, 0x4d,
4664 contents
+ roff
- 3);
4665 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4666 bfd_put_8 (output_bfd
, 0x45,
4667 contents
+ roff
- 3);
4668 bfd_put_8 (output_bfd
, 0x8d,
4669 contents
+ roff
- 2);
4670 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4671 contents
+ roff
- 1);
4673 bfd_put_32 (output_bfd
,
4674 elf_x86_64_tpoff (info
, relocation
),
4682 if (htab
->elf
.sgot
== NULL
)
4687 off
= h
->got
.offset
;
4688 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4692 if (local_got_offsets
== NULL
)
4695 off
= local_got_offsets
[r_symndx
];
4696 offplt
= local_tlsdesc_gotents
[r_symndx
];
4703 Elf_Internal_Rela outrel
;
4707 if (htab
->elf
.srelgot
== NULL
)
4710 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4712 if (GOT_TLS_GDESC_P (tls_type
))
4714 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4715 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4716 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4717 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4718 + htab
->elf
.sgotplt
->output_offset
4720 + htab
->sgotplt_jump_table_size
);
4721 sreloc
= htab
->elf
.srelplt
;
4723 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4725 outrel
.r_addend
= 0;
4726 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4729 sreloc
= htab
->elf
.srelgot
;
4731 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4732 + htab
->elf
.sgot
->output_offset
+ off
);
4734 if (GOT_TLS_GD_P (tls_type
))
4735 dr_type
= R_X86_64_DTPMOD64
;
4736 else if (GOT_TLS_GDESC_P (tls_type
))
4739 dr_type
= R_X86_64_TPOFF64
;
4741 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4742 outrel
.r_addend
= 0;
4743 if ((dr_type
== R_X86_64_TPOFF64
4744 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4745 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4746 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4748 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4750 if (GOT_TLS_GD_P (tls_type
))
4754 BFD_ASSERT (! unresolved_reloc
);
4755 bfd_put_64 (output_bfd
,
4756 relocation
- elf_x86_64_dtpoff_base (info
),
4757 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4761 bfd_put_64 (output_bfd
, 0,
4762 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4763 outrel
.r_info
= htab
->r_info (indx
,
4765 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4766 elf_append_rela (output_bfd
, sreloc
,
4775 local_got_offsets
[r_symndx
] |= 1;
4778 if (off
>= (bfd_vma
) -2
4779 && ! GOT_TLS_GDESC_P (tls_type
))
4781 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4783 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4784 || r_type
== R_X86_64_TLSDESC_CALL
)
4785 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4786 + htab
->elf
.sgotplt
->output_offset
4787 + offplt
+ htab
->sgotplt_jump_table_size
;
4789 relocation
= htab
->elf
.sgot
->output_section
->vma
4790 + htab
->elf
.sgot
->output_offset
+ off
;
4791 unresolved_reloc
= FALSE
;
4795 bfd_vma roff
= rel
->r_offset
;
4797 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4799 /* GD->IE transition. For 64bit, change
4800 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4801 .word 0x6666; rex64; call __tls_get_addr@plt
4804 addq foo@gottpoff(%rip), %rax
4806 leaq foo@tlsgd(%rip), %rdi
4807 .word 0x6666; rex64; call __tls_get_addr@plt
4810 addq foo@gottpoff(%rip), %rax
4811 For largepic, change:
4812 leaq foo@tlsgd(%rip), %rdi
4813 movabsq $__tls_get_addr@pltoff, %rax
4818 addq foo@gottpoff(%rax), %rax
4819 nopw 0x0(%rax,%rax,1) */
4821 if (ABI_64_P (output_bfd
)
4822 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4824 memcpy (contents
+ roff
- 3,
4825 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4826 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4829 else if (ABI_64_P (output_bfd
))
4830 memcpy (contents
+ roff
- 4,
4831 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4834 memcpy (contents
+ roff
- 3,
4835 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4838 relocation
= (htab
->elf
.sgot
->output_section
->vma
4839 + htab
->elf
.sgot
->output_offset
+ off
4842 - input_section
->output_section
->vma
4843 - input_section
->output_offset
4845 bfd_put_32 (output_bfd
, relocation
,
4846 contents
+ roff
+ 8 + largepic
);
4847 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4851 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4853 /* GDesc -> IE transition.
4854 It's originally something like:
4855 leaq x@tlsdesc(%rip), %rax
4858 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4860 /* Now modify the instruction as appropriate. To
4861 turn a leaq into a movq in the form we use it, it
4862 suffices to change the second byte from 0x8d to
4864 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4866 bfd_put_32 (output_bfd
,
4867 htab
->elf
.sgot
->output_section
->vma
4868 + htab
->elf
.sgot
->output_offset
+ off
4870 - input_section
->output_section
->vma
4871 - input_section
->output_offset
4876 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4878 /* GDesc -> IE transition.
4885 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4886 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4894 case R_X86_64_TLSLD
:
4895 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4896 input_section
, contents
,
4897 symtab_hdr
, sym_hashes
,
4898 &r_type
, GOT_UNKNOWN
,
4899 rel
, relend
, h
, r_symndx
))
4902 if (r_type
!= R_X86_64_TLSLD
)
4904 /* LD->LE transition:
4905 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4906 For 64bit, we change it into:
4907 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4908 For 32bit, we change it into:
4909 nopl 0x0(%rax); movl %fs:0, %eax.
4910 For largepic, change:
4911 leaq foo@tlsgd(%rip), %rdi
4912 movabsq $__tls_get_addr@pltoff, %rax
4916 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4919 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4920 if (ABI_64_P (output_bfd
)
4921 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4922 memcpy (contents
+ rel
->r_offset
- 3,
4923 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4924 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4925 else if (ABI_64_P (output_bfd
))
4926 memcpy (contents
+ rel
->r_offset
- 3,
4927 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4929 memcpy (contents
+ rel
->r_offset
- 3,
4930 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4931 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4936 if (htab
->elf
.sgot
== NULL
)
4939 off
= htab
->tls_ld_got
.offset
;
4944 Elf_Internal_Rela outrel
;
4946 if (htab
->elf
.srelgot
== NULL
)
4949 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4950 + htab
->elf
.sgot
->output_offset
+ off
);
4952 bfd_put_64 (output_bfd
, 0,
4953 htab
->elf
.sgot
->contents
+ off
);
4954 bfd_put_64 (output_bfd
, 0,
4955 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4956 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4957 outrel
.r_addend
= 0;
4958 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4960 htab
->tls_ld_got
.offset
|= 1;
4962 relocation
= htab
->elf
.sgot
->output_section
->vma
4963 + htab
->elf
.sgot
->output_offset
+ off
;
4964 unresolved_reloc
= FALSE
;
4967 case R_X86_64_DTPOFF32
:
4968 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4969 relocation
-= elf_x86_64_dtpoff_base (info
);
4971 relocation
= elf_x86_64_tpoff (info
, relocation
);
4974 case R_X86_64_TPOFF32
:
4975 case R_X86_64_TPOFF64
:
4976 BFD_ASSERT (info
->executable
);
4977 relocation
= elf_x86_64_tpoff (info
, relocation
);
4980 case R_X86_64_DTPOFF64
:
4981 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4982 relocation
-= elf_x86_64_dtpoff_base (info
);
4989 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4990 because such sections are not SEC_ALLOC and thus ld.so will
4991 not process them. */
4992 if (unresolved_reloc
4993 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4995 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4996 rel
->r_offset
) != (bfd_vma
) -1)
4998 (*_bfd_error_handler
)
4999 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5002 (long) rel
->r_offset
,
5004 h
->root
.root
.string
);
5009 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5010 contents
, rel
->r_offset
,
5011 relocation
, rel
->r_addend
);
5013 check_relocation_error
:
5014 if (r
!= bfd_reloc_ok
)
5019 name
= h
->root
.root
.string
;
5022 name
= bfd_elf_string_from_elf_section (input_bfd
,
5023 symtab_hdr
->sh_link
,
5028 name
= bfd_section_name (input_bfd
, sec
);
5031 if (r
== bfd_reloc_overflow
)
5033 if (! ((*info
->callbacks
->reloc_overflow
)
5034 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5035 (bfd_vma
) 0, input_bfd
, input_section
,
5041 (*_bfd_error_handler
)
5042 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5043 input_bfd
, input_section
,
5044 (long) rel
->r_offset
, name
, (int) r
);
5053 /* Finish up dynamic symbol handling. We set the contents of various
5054 dynamic sections here. */
5057 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5058 struct bfd_link_info
*info
,
5059 struct elf_link_hash_entry
*h
,
5060 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
5062 struct elf_x86_64_link_hash_table
*htab
;
5063 const struct elf_x86_64_backend_data
*abed
;
5064 bfd_boolean use_plt_bnd
;
5065 struct elf_x86_64_link_hash_entry
*eh
;
5067 htab
= elf_x86_64_hash_table (info
);
5071 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5072 section only if there is .plt section. */
5073 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5075 ? &elf_x86_64_bnd_arch_bed
5076 : get_elf_x86_64_backend_data (output_bfd
));
5078 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5080 if (h
->plt
.offset
!= (bfd_vma
) -1)
5083 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5084 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5085 Elf_Internal_Rela rela
;
5087 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5088 const struct elf_backend_data
*bed
;
5089 bfd_vma plt_got_pcrel_offset
;
5091 /* When building a static executable, use .iplt, .igot.plt and
5092 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5093 if (htab
->elf
.splt
!= NULL
)
5095 plt
= htab
->elf
.splt
;
5096 gotplt
= htab
->elf
.sgotplt
;
5097 relplt
= htab
->elf
.srelplt
;
5101 plt
= htab
->elf
.iplt
;
5102 gotplt
= htab
->elf
.igotplt
;
5103 relplt
= htab
->elf
.irelplt
;
5106 /* This symbol has an entry in the procedure linkage table. Set
5108 if ((h
->dynindx
== -1
5109 && !((h
->forced_local
|| info
->executable
)
5111 && h
->type
== STT_GNU_IFUNC
))
5117 /* Get the index in the procedure linkage table which
5118 corresponds to this symbol. This is the index of this symbol
5119 in all the symbols for which we are making plt entries. The
5120 first entry in the procedure linkage table is reserved.
5122 Get the offset into the .got table of the entry that
5123 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5124 bytes. The first three are reserved for the dynamic linker.
5126 For static executables, we don't reserve anything. */
5128 if (plt
== htab
->elf
.splt
)
5130 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5131 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5135 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5136 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5139 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5140 plt_plt_offset
= abed
->plt_plt_offset
;
5141 plt_got_insn_size
= abed
->plt_got_insn_size
;
5142 plt_got_offset
= abed
->plt_got_offset
;
5145 /* Use the second PLT with BND relocations. */
5146 const bfd_byte
*plt_entry
, *plt2_entry
;
5148 if (eh
->has_bnd_reloc
)
5150 plt_entry
= elf_x86_64_bnd_plt_entry
;
5151 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5155 plt_entry
= elf_x86_64_legacy_plt_entry
;
5156 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5158 /* Subtract 1 since there is no BND prefix. */
5159 plt_plt_insn_end
-= 1;
5160 plt_plt_offset
-= 1;
5161 plt_got_insn_size
-= 1;
5162 plt_got_offset
-= 1;
5165 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5166 == sizeof (elf_x86_64_legacy_plt_entry
));
5168 /* Fill in the entry in the procedure linkage table. */
5169 memcpy (plt
->contents
+ h
->plt
.offset
,
5170 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5171 /* Fill in the entry in the second PLT. */
5172 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5173 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5175 resolved_plt
= htab
->plt_bnd
;
5176 plt_offset
= eh
->plt_bnd
.offset
;
5180 /* Fill in the entry in the procedure linkage table. */
5181 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5182 abed
->plt_entry_size
);
5185 plt_offset
= h
->plt
.offset
;
5188 /* Insert the relocation positions of the plt section. */
5190 /* Put offset the PC-relative instruction referring to the GOT entry,
5191 subtracting the size of that instruction. */
5192 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5193 + gotplt
->output_offset
5195 - resolved_plt
->output_section
->vma
5196 - resolved_plt
->output_offset
5198 - plt_got_insn_size
);
5200 /* Check PC-relative offset overflow in PLT entry. */
5201 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5202 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5203 output_bfd
, h
->root
.root
.string
);
5205 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5206 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5208 /* Fill in the entry in the global offset table, initially this
5209 points to the second part of the PLT entry. */
5210 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5211 + plt
->output_offset
5212 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
5213 gotplt
->contents
+ got_offset
);
5215 /* Fill in the entry in the .rela.plt section. */
5216 rela
.r_offset
= (gotplt
->output_section
->vma
5217 + gotplt
->output_offset
5219 if (h
->dynindx
== -1
5220 || ((info
->executable
5221 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5223 && h
->type
== STT_GNU_IFUNC
))
5225 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5226 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5227 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5228 rela
.r_addend
= (h
->root
.u
.def
.value
5229 + h
->root
.u
.def
.section
->output_section
->vma
5230 + h
->root
.u
.def
.section
->output_offset
);
5231 /* R_X86_64_IRELATIVE comes last. */
5232 plt_index
= htab
->next_irelative_index
--;
5236 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5238 plt_index
= htab
->next_jump_slot_index
++;
5241 /* Don't fill PLT entry for static executables. */
5242 if (plt
== htab
->elf
.splt
)
5244 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5246 /* Put relocation index. */
5247 bfd_put_32 (output_bfd
, plt_index
,
5248 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
5250 /* Put offset for jmp .PLT0 and check for overflow. We don't
5251 check relocation index for overflow since branch displacement
5252 will overflow first. */
5253 if (plt0_offset
> 0x80000000)
5254 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5255 output_bfd
, h
->root
.root
.string
);
5256 bfd_put_32 (output_bfd
, - plt0_offset
,
5257 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5260 bed
= get_elf_backend_data (output_bfd
);
5261 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5262 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5264 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5266 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5267 asection
*plt
, *got
;
5268 bfd_boolean got_after_plt
;
5269 int32_t got_pcrel_offset
;
5270 const bfd_byte
*got_plt_entry
;
5272 /* Set the entry in the GOT procedure linkage table. */
5273 plt
= htab
->plt_got
;
5274 got
= htab
->elf
.sgot
;
5275 got_offset
= h
->got
.offset
;
5277 if (got_offset
== (bfd_vma
) -1
5278 || h
->type
== STT_GNU_IFUNC
5283 /* Use the second PLT entry template for the GOT PLT since they
5284 are the identical. */
5285 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5286 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5287 if (eh
->has_bnd_reloc
)
5288 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5291 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5293 /* Subtract 1 since there is no BND prefix. */
5294 plt_got_insn_size
-= 1;
5295 plt_got_offset
-= 1;
5298 /* Fill in the entry in the GOT procedure linkage table. */
5299 plt_offset
= eh
->plt_got
.offset
;
5300 memcpy (plt
->contents
+ plt_offset
,
5301 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5303 /* Put offset the PC-relative instruction referring to the GOT
5304 entry, subtracting the size of that instruction. */
5305 got_pcrel_offset
= (got
->output_section
->vma
5306 + got
->output_offset
5308 - plt
->output_section
->vma
5309 - plt
->output_offset
5311 - plt_got_insn_size
);
5313 /* Check PC-relative offset overflow in GOT PLT entry. */
5314 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5315 if ((got_after_plt
&& got_pcrel_offset
< 0)
5316 || (!got_after_plt
&& got_pcrel_offset
> 0))
5317 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5318 output_bfd
, h
->root
.root
.string
);
5320 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5321 plt
->contents
+ plt_offset
+ plt_got_offset
);
5325 && (h
->plt
.offset
!= (bfd_vma
) -1
5326 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5328 /* Mark the symbol as undefined, rather than as defined in
5329 the .plt section. Leave the value if there were any
5330 relocations where pointer equality matters (this is a clue
5331 for the dynamic linker, to make function pointer
5332 comparisons work between an application and shared
5333 library), otherwise set it to zero. If a function is only
5334 called from a binary, there is no need to slow down
5335 shared libraries because of that. */
5336 sym
->st_shndx
= SHN_UNDEF
;
5337 if (!h
->pointer_equality_needed
)
5341 if (h
->got
.offset
!= (bfd_vma
) -1
5342 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5343 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
5345 Elf_Internal_Rela rela
;
5347 /* This symbol has an entry in the global offset table. Set it
5349 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5352 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5353 + htab
->elf
.sgot
->output_offset
5354 + (h
->got
.offset
&~ (bfd_vma
) 1));
5356 /* If this is a static link, or it is a -Bsymbolic link and the
5357 symbol is defined locally or was forced to be local because
5358 of a version file, we just want to emit a RELATIVE reloc.
5359 The entry in the global offset table will already have been
5360 initialized in the relocate_section function. */
5362 && h
->type
== STT_GNU_IFUNC
)
5366 /* Generate R_X86_64_GLOB_DAT. */
5373 if (!h
->pointer_equality_needed
)
5376 /* For non-shared object, we can't use .got.plt, which
5377 contains the real function addres if we need pointer
5378 equality. We load the GOT entry with the PLT entry. */
5379 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5380 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5381 + plt
->output_offset
5383 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5387 else if (info
->shared
5388 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5390 if (!h
->def_regular
)
5392 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5393 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5394 rela
.r_addend
= (h
->root
.u
.def
.value
5395 + h
->root
.u
.def
.section
->output_section
->vma
5396 + h
->root
.u
.def
.section
->output_offset
);
5400 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5402 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5403 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5404 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5408 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5413 Elf_Internal_Rela rela
;
5415 /* This symbol needs a copy reloc. Set it up. */
5417 if (h
->dynindx
== -1
5418 || (h
->root
.type
!= bfd_link_hash_defined
5419 && h
->root
.type
!= bfd_link_hash_defweak
)
5420 || htab
->srelbss
== NULL
)
5423 rela
.r_offset
= (h
->root
.u
.def
.value
5424 + h
->root
.u
.def
.section
->output_section
->vma
5425 + h
->root
.u
.def
.section
->output_offset
);
5426 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5428 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5434 /* Finish up local dynamic symbol handling. We set the contents of
5435 various dynamic sections here. */
5438 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5440 struct elf_link_hash_entry
*h
5441 = (struct elf_link_hash_entry
*) *slot
;
5442 struct bfd_link_info
*info
5443 = (struct bfd_link_info
*) inf
;
5445 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5449 /* Used to decide how to sort relocs in an optimal manner for the
5450 dynamic linker, before writing them out. */
5452 static enum elf_reloc_type_class
5453 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5454 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5455 const Elf_Internal_Rela
*rela
)
5457 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5459 case R_X86_64_RELATIVE
:
5460 case R_X86_64_RELATIVE64
:
5461 return reloc_class_relative
;
5462 case R_X86_64_JUMP_SLOT
:
5463 return reloc_class_plt
;
5465 return reloc_class_copy
;
5467 return reloc_class_normal
;
5471 /* Finish up the dynamic sections. */
5474 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5475 struct bfd_link_info
*info
)
5477 struct elf_x86_64_link_hash_table
*htab
;
5480 const struct elf_x86_64_backend_data
*abed
;
5482 htab
= elf_x86_64_hash_table (info
);
5486 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5487 section only if there is .plt section. */
5488 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5489 ? &elf_x86_64_bnd_arch_bed
5490 : get_elf_x86_64_backend_data (output_bfd
));
5492 dynobj
= htab
->elf
.dynobj
;
5493 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5495 if (htab
->elf
.dynamic_sections_created
)
5497 bfd_byte
*dyncon
, *dynconend
;
5498 const struct elf_backend_data
*bed
;
5499 bfd_size_type sizeof_dyn
;
5501 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5504 bed
= get_elf_backend_data (dynobj
);
5505 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5506 dyncon
= sdyn
->contents
;
5507 dynconend
= sdyn
->contents
+ sdyn
->size
;
5508 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5510 Elf_Internal_Dyn dyn
;
5513 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5521 s
= htab
->elf
.sgotplt
;
5522 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5526 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5530 s
= htab
->elf
.srelplt
->output_section
;
5531 dyn
.d_un
.d_val
= s
->size
;
5535 /* The procedure linkage table relocs (DT_JMPREL) should
5536 not be included in the overall relocs (DT_RELA).
5537 Therefore, we override the DT_RELASZ entry here to
5538 make it not include the JMPREL relocs. Since the
5539 linker script arranges for .rela.plt to follow all
5540 other relocation sections, we don't have to worry
5541 about changing the DT_RELA entry. */
5542 if (htab
->elf
.srelplt
!= NULL
)
5544 s
= htab
->elf
.srelplt
->output_section
;
5545 dyn
.d_un
.d_val
-= s
->size
;
5549 case DT_TLSDESC_PLT
:
5551 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5552 + htab
->tlsdesc_plt
;
5555 case DT_TLSDESC_GOT
:
5557 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5558 + htab
->tlsdesc_got
;
5562 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5565 /* Fill in the special first entry in the procedure linkage table. */
5566 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5568 /* Fill in the first entry in the procedure linkage table. */
5569 memcpy (htab
->elf
.splt
->contents
,
5570 abed
->plt0_entry
, abed
->plt_entry_size
);
5571 /* Add offset for pushq GOT+8(%rip), since the instruction
5572 uses 6 bytes subtract this value. */
5573 bfd_put_32 (output_bfd
,
5574 (htab
->elf
.sgotplt
->output_section
->vma
5575 + htab
->elf
.sgotplt
->output_offset
5577 - htab
->elf
.splt
->output_section
->vma
5578 - htab
->elf
.splt
->output_offset
5580 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5581 /* Add offset for the PC-relative instruction accessing GOT+16,
5582 subtracting the offset to the end of that instruction. */
5583 bfd_put_32 (output_bfd
,
5584 (htab
->elf
.sgotplt
->output_section
->vma
5585 + htab
->elf
.sgotplt
->output_offset
5587 - htab
->elf
.splt
->output_section
->vma
5588 - htab
->elf
.splt
->output_offset
5589 - abed
->plt0_got2_insn_end
),
5590 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5592 elf_section_data (htab
->elf
.splt
->output_section
)
5593 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5595 if (htab
->tlsdesc_plt
)
5597 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5598 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5600 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5601 abed
->plt0_entry
, abed
->plt_entry_size
);
5603 /* Add offset for pushq GOT+8(%rip), since the
5604 instruction uses 6 bytes subtract this value. */
5605 bfd_put_32 (output_bfd
,
5606 (htab
->elf
.sgotplt
->output_section
->vma
5607 + htab
->elf
.sgotplt
->output_offset
5609 - htab
->elf
.splt
->output_section
->vma
5610 - htab
->elf
.splt
->output_offset
5613 htab
->elf
.splt
->contents
5614 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5615 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5616 where TGD stands for htab->tlsdesc_got, subtracting the offset
5617 to the end of that instruction. */
5618 bfd_put_32 (output_bfd
,
5619 (htab
->elf
.sgot
->output_section
->vma
5620 + htab
->elf
.sgot
->output_offset
5622 - htab
->elf
.splt
->output_section
->vma
5623 - htab
->elf
.splt
->output_offset
5625 - abed
->plt0_got2_insn_end
),
5626 htab
->elf
.splt
->contents
5627 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5632 if (htab
->plt_bnd
!= NULL
)
5633 elf_section_data (htab
->plt_bnd
->output_section
)
5634 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5636 if (htab
->elf
.sgotplt
)
5638 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5640 (*_bfd_error_handler
)
5641 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5645 /* Fill in the first three entries in the global offset table. */
5646 if (htab
->elf
.sgotplt
->size
> 0)
5648 /* Set the first entry in the global offset table to the address of
5649 the dynamic section. */
5651 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5653 bfd_put_64 (output_bfd
,
5654 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5655 htab
->elf
.sgotplt
->contents
);
5656 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5657 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5658 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5661 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5665 /* Adjust .eh_frame for .plt section. */
5666 if (htab
->plt_eh_frame
!= NULL
5667 && htab
->plt_eh_frame
->contents
!= NULL
)
5669 if (htab
->elf
.splt
!= NULL
5670 && htab
->elf
.splt
->size
!= 0
5671 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5672 && htab
->elf
.splt
->output_section
!= NULL
5673 && htab
->plt_eh_frame
->output_section
!= NULL
)
5675 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5676 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5677 + htab
->plt_eh_frame
->output_offset
5678 + PLT_FDE_START_OFFSET
;
5679 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5680 htab
->plt_eh_frame
->contents
5681 + PLT_FDE_START_OFFSET
);
5683 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5685 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5687 htab
->plt_eh_frame
->contents
))
5692 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5693 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5696 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5697 htab_traverse (htab
->loc_hash_table
,
5698 elf_x86_64_finish_local_dynamic_symbol
,
5704 /* Return an array of PLT entry symbol values. */
5707 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5710 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5713 bfd_vma
*plt_sym_val
;
5715 bfd_byte
*plt_contents
;
5716 const struct elf_x86_64_backend_data
*bed
;
5717 Elf_Internal_Shdr
*hdr
;
5720 /* Get the .plt section contents. PLT passed down may point to the
5721 .plt.bnd section. Make sure that PLT always points to the .plt
5723 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5728 plt
= bfd_get_section_by_name (abfd
, ".plt");
5731 bed
= &elf_x86_64_bnd_arch_bed
;
5734 bed
= get_elf_x86_64_backend_data (abfd
);
5736 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5737 if (plt_contents
== NULL
)
5739 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5740 plt_contents
, 0, plt
->size
))
5743 free (plt_contents
);
5747 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5748 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5751 hdr
= &elf_section_data (relplt
)->this_hdr
;
5752 count
= relplt
->size
/ hdr
->sh_entsize
;
5754 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5755 if (plt_sym_val
== NULL
)
5758 for (i
= 0; i
< count
; i
++)
5759 plt_sym_val
[i
] = -1;
5761 plt_offset
= bed
->plt_entry_size
;
5762 p
= relplt
->relocation
;
5763 for (i
= 0; i
< count
; i
++, p
++)
5767 /* Skip unknown relocation. */
5768 if (p
->howto
== NULL
)
5771 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5772 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5775 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5776 + bed
->plt_reloc_offset
));
5777 if (reloc_index
>= count
)
5781 /* This is the index in .plt section. */
5782 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5783 /* Store VMA + the offset in .plt.bnd section. */
5784 plt_sym_val
[reloc_index
] =
5786 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
5789 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5790 plt_offset
+= bed
->plt_entry_size
;
5792 /* PR binutils/18437: Skip extra relocations in the .rela.plt
5794 if (plt_offset
>= plt
->size
)
5798 free (plt_contents
);
5803 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5807 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5814 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
5815 as PLT if it exists. */
5816 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5818 plt
= bfd_get_section_by_name (abfd
, ".plt");
5819 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5820 dynsymcount
, dynsyms
, ret
,
5822 elf_x86_64_get_plt_sym_val
);
5825 /* Handle an x86-64 specific section when reading an object file. This
5826 is called when elfcode.h finds a section with an unknown type. */
5829 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5830 const char *name
, int shindex
)
5832 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5835 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5841 /* Hook called by the linker routine which adds symbols from an object
5842 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5846 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5847 struct bfd_link_info
*info
,
5848 Elf_Internal_Sym
*sym
,
5849 const char **namep ATTRIBUTE_UNUSED
,
5850 flagword
*flagsp ATTRIBUTE_UNUSED
,
5856 switch (sym
->st_shndx
)
5858 case SHN_X86_64_LCOMMON
:
5859 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5862 lcomm
= bfd_make_section_with_flags (abfd
,
5866 | SEC_LINKER_CREATED
));
5869 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5872 *valp
= sym
->st_size
;
5876 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5877 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
5878 && (abfd
->flags
& DYNAMIC
) == 0
5879 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5880 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5886 /* Given a BFD section, try to locate the corresponding ELF section
5890 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5891 asection
*sec
, int *index_return
)
5893 if (sec
== &_bfd_elf_large_com_section
)
5895 *index_return
= SHN_X86_64_LCOMMON
;
5901 /* Process a symbol. */
5904 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5907 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5909 switch (elfsym
->internal_elf_sym
.st_shndx
)
5911 case SHN_X86_64_LCOMMON
:
5912 asym
->section
= &_bfd_elf_large_com_section
;
5913 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5914 /* Common symbol doesn't set BSF_GLOBAL. */
5915 asym
->flags
&= ~BSF_GLOBAL
;
5921 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5923 return (sym
->st_shndx
== SHN_COMMON
5924 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5928 elf_x86_64_common_section_index (asection
*sec
)
5930 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5933 return SHN_X86_64_LCOMMON
;
5937 elf_x86_64_common_section (asection
*sec
)
5939 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5940 return bfd_com_section_ptr
;
5942 return &_bfd_elf_large_com_section
;
5946 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5947 const Elf_Internal_Sym
*sym
,
5952 const asection
*oldsec
)
5954 /* A normal common symbol and a large common symbol result in a
5955 normal common symbol. We turn the large common symbol into a
5958 && h
->root
.type
== bfd_link_hash_common
5960 && bfd_is_com_section (*psec
)
5963 if (sym
->st_shndx
== SHN_COMMON
5964 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5966 h
->root
.u
.c
.p
->section
5967 = bfd_make_section_old_way (oldbfd
, "COMMON");
5968 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5970 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5971 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5972 *psec
= bfd_com_section_ptr
;
5979 elf_x86_64_additional_program_headers (bfd
*abfd
,
5980 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5985 /* Check to see if we need a large readonly segment. */
5986 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5987 if (s
&& (s
->flags
& SEC_LOAD
))
5990 /* Check to see if we need a large data segment. Since .lbss sections
5991 is placed right after the .bss section, there should be no need for
5992 a large data segment just because of .lbss. */
5993 s
= bfd_get_section_by_name (abfd
, ".ldata");
5994 if (s
&& (s
->flags
& SEC_LOAD
))
6000 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6003 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6005 if (h
->plt
.offset
!= (bfd_vma
) -1
6007 && !h
->pointer_equality_needed
)
6010 return _bfd_elf_hash_symbol (h
);
6013 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6016 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6017 const bfd_target
*output
)
6019 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6020 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6021 && _bfd_elf_relocs_compatible (input
, output
));
6024 static const struct bfd_elf_special_section
6025 elf_x86_64_special_sections
[]=
6027 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6028 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6029 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6030 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6031 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6032 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6033 { NULL
, 0, 0, 0, 0 }
6036 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6037 #define TARGET_LITTLE_NAME "elf64-x86-64"
6038 #define ELF_ARCH bfd_arch_i386
6039 #define ELF_TARGET_ID X86_64_ELF_DATA
6040 #define ELF_MACHINE_CODE EM_X86_64
6041 #define ELF_MAXPAGESIZE 0x200000
6042 #define ELF_MINPAGESIZE 0x1000
6043 #define ELF_COMMONPAGESIZE 0x1000
6045 #define elf_backend_can_gc_sections 1
6046 #define elf_backend_can_refcount 1
6047 #define elf_backend_want_got_plt 1
6048 #define elf_backend_plt_readonly 1
6049 #define elf_backend_want_plt_sym 0
6050 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6051 #define elf_backend_rela_normal 1
6052 #define elf_backend_plt_alignment 4
6053 #define elf_backend_extern_protected_data 1
6055 #define elf_info_to_howto elf_x86_64_info_to_howto
6057 #define bfd_elf64_bfd_link_hash_table_create \
6058 elf_x86_64_link_hash_table_create
6059 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6060 #define bfd_elf64_bfd_reloc_name_lookup \
6061 elf_x86_64_reloc_name_lookup
6063 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6064 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6065 #define elf_backend_check_relocs elf_x86_64_check_relocs
6066 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6067 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6068 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6069 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6070 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6071 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6072 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6073 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6075 #define elf_backend_write_core_note elf_x86_64_write_core_note
6077 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6078 #define elf_backend_relocate_section elf_x86_64_relocate_section
6079 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6080 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6081 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6082 #define elf_backend_object_p elf64_x86_64_elf_object_p
6083 #define bfd_elf64_mkobject elf_x86_64_mkobject
6084 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6086 #define elf_backend_section_from_shdr \
6087 elf_x86_64_section_from_shdr
6089 #define elf_backend_section_from_bfd_section \
6090 elf_x86_64_elf_section_from_bfd_section
6091 #define elf_backend_add_symbol_hook \
6092 elf_x86_64_add_symbol_hook
6093 #define elf_backend_symbol_processing \
6094 elf_x86_64_symbol_processing
6095 #define elf_backend_common_section_index \
6096 elf_x86_64_common_section_index
6097 #define elf_backend_common_section \
6098 elf_x86_64_common_section
6099 #define elf_backend_common_definition \
6100 elf_x86_64_common_definition
6101 #define elf_backend_merge_symbol \
6102 elf_x86_64_merge_symbol
6103 #define elf_backend_special_sections \
6104 elf_x86_64_special_sections
6105 #define elf_backend_additional_program_headers \
6106 elf_x86_64_additional_program_headers
6107 #define elf_backend_hash_symbol \
6108 elf_x86_64_hash_symbol
6110 #include "elf64-target.h"
6112 /* CloudABI support. */
6114 #undef TARGET_LITTLE_SYM
6115 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6116 #undef TARGET_LITTLE_NAME
6117 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6120 #define ELF_OSABI ELFOSABI_CLOUDABI
6123 #define elf64_bed elf64_x86_64_cloudabi_bed
6125 #include "elf64-target.h"
6127 /* FreeBSD support. */
6129 #undef TARGET_LITTLE_SYM
6130 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6131 #undef TARGET_LITTLE_NAME
6132 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6135 #define ELF_OSABI ELFOSABI_FREEBSD
6138 #define elf64_bed elf64_x86_64_fbsd_bed
6140 #include "elf64-target.h"
6142 /* Solaris 2 support. */
6144 #undef TARGET_LITTLE_SYM
6145 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6146 #undef TARGET_LITTLE_NAME
6147 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6149 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6150 objects won't be recognized. */
6154 #define elf64_bed elf64_x86_64_sol2_bed
6156 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6158 #undef elf_backend_static_tls_alignment
6159 #define elf_backend_static_tls_alignment 16
6161 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6163 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6165 #undef elf_backend_want_plt_sym
6166 #define elf_backend_want_plt_sym 1
6168 #include "elf64-target.h"
6170 /* Native Client support. */
6173 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6175 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6176 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6180 #undef TARGET_LITTLE_SYM
6181 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6182 #undef TARGET_LITTLE_NAME
6183 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6185 #define elf64_bed elf64_x86_64_nacl_bed
6187 #undef ELF_MAXPAGESIZE
6188 #undef ELF_MINPAGESIZE
6189 #undef ELF_COMMONPAGESIZE
6190 #define ELF_MAXPAGESIZE 0x10000
6191 #define ELF_MINPAGESIZE 0x10000
6192 #define ELF_COMMONPAGESIZE 0x10000
6194 /* Restore defaults. */
6196 #undef elf_backend_static_tls_alignment
6197 #undef elf_backend_want_plt_sym
6198 #define elf_backend_want_plt_sym 0
6200 /* NaCl uses substantially different PLT entries for the same effects. */
6202 #undef elf_backend_plt_alignment
6203 #define elf_backend_plt_alignment 5
6204 #define NACL_PLT_ENTRY_SIZE 64
6205 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6207 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6209 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6210 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6211 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6212 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6213 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6215 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6216 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6218 /* 32 bytes of nop to pad out to the standard size. */
6219 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6220 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6221 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6222 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6223 0x66, /* excess data32 prefix */
6227 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6229 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6230 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6231 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6232 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6234 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6235 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6236 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6238 /* Lazy GOT entries point here (32-byte aligned). */
6239 0x68, /* pushq immediate */
6240 0, 0, 0, 0, /* replaced with index into relocation table. */
6241 0xe9, /* jmp relative */
6242 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6244 /* 22 bytes of nop to pad out to the standard size. */
6245 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6246 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6247 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6250 /* .eh_frame covering the .plt section. */
6252 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6254 #if (PLT_CIE_LENGTH != 20 \
6255 || PLT_FDE_LENGTH != 36 \
6256 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6257 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6258 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6260 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6261 0, 0, 0, 0, /* CIE ID */
6262 1, /* CIE version */
6263 'z', 'R', 0, /* Augmentation string */
6264 1, /* Code alignment factor */
6265 0x78, /* Data alignment factor */
6266 16, /* Return address column */
6267 1, /* Augmentation size */
6268 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6269 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6270 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6271 DW_CFA_nop
, DW_CFA_nop
,
6273 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6274 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6275 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6276 0, 0, 0, 0, /* .plt size goes here */
6277 0, /* Augmentation size */
6278 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6279 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6280 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6281 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6282 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6283 13, /* Block length */
6284 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6285 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6286 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6287 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6288 DW_CFA_nop
, DW_CFA_nop
6291 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6293 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6294 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6295 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6296 2, /* plt0_got1_offset */
6297 9, /* plt0_got2_offset */
6298 13, /* plt0_got2_insn_end */
6299 3, /* plt_got_offset */
6300 33, /* plt_reloc_offset */
6301 38, /* plt_plt_offset */
6302 7, /* plt_got_insn_size */
6303 42, /* plt_plt_insn_end */
6304 32, /* plt_lazy_offset */
6305 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6306 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6309 #undef elf_backend_arch_data
6310 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6312 #undef elf_backend_object_p
6313 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6314 #undef elf_backend_modify_segment_map
6315 #define elf_backend_modify_segment_map nacl_modify_segment_map
6316 #undef elf_backend_modify_program_headers
6317 #define elf_backend_modify_program_headers nacl_modify_program_headers
6318 #undef elf_backend_final_write_processing
6319 #define elf_backend_final_write_processing nacl_final_write_processing
6321 #include "elf64-target.h"
6323 /* Native Client x32 support. */
6326 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6328 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6329 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6333 #undef TARGET_LITTLE_SYM
6334 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6335 #undef TARGET_LITTLE_NAME
6336 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6338 #define elf32_bed elf32_x86_64_nacl_bed
6340 #define bfd_elf32_bfd_link_hash_table_create \
6341 elf_x86_64_link_hash_table_create
6342 #define bfd_elf32_bfd_reloc_type_lookup \
6343 elf_x86_64_reloc_type_lookup
6344 #define bfd_elf32_bfd_reloc_name_lookup \
6345 elf_x86_64_reloc_name_lookup
6346 #define bfd_elf32_mkobject \
6348 #define bfd_elf32_get_synthetic_symtab \
6349 elf_x86_64_get_synthetic_symtab
6351 #undef elf_backend_object_p
6352 #define elf_backend_object_p \
6353 elf32_x86_64_nacl_elf_object_p
6355 #undef elf_backend_bfd_from_remote_memory
6356 #define elf_backend_bfd_from_remote_memory \
6357 _bfd_elf32_bfd_from_remote_memory
6359 #undef elf_backend_size_info
6360 #define elf_backend_size_info \
6361 _bfd_elf32_size_info
6363 #include "elf32-target.h"
6365 /* Restore defaults. */
6366 #undef elf_backend_object_p
6367 #define elf_backend_object_p elf64_x86_64_elf_object_p
6368 #undef elf_backend_bfd_from_remote_memory
6369 #undef elf_backend_size_info
6370 #undef elf_backend_modify_segment_map
6371 #undef elf_backend_modify_program_headers
6372 #undef elf_backend_final_write_processing
6374 /* Intel L1OM support. */
6377 elf64_l1om_elf_object_p (bfd
*abfd
)
6379 /* Set the right machine number for an L1OM elf64 file. */
6380 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6384 #undef TARGET_LITTLE_SYM
6385 #define TARGET_LITTLE_SYM l1om_elf64_vec
6386 #undef TARGET_LITTLE_NAME
6387 #define TARGET_LITTLE_NAME "elf64-l1om"
6389 #define ELF_ARCH bfd_arch_l1om
6391 #undef ELF_MACHINE_CODE
6392 #define ELF_MACHINE_CODE EM_L1OM
6397 #define elf64_bed elf64_l1om_bed
6399 #undef elf_backend_object_p
6400 #define elf_backend_object_p elf64_l1om_elf_object_p
6402 /* Restore defaults. */
6403 #undef ELF_MAXPAGESIZE
6404 #undef ELF_MINPAGESIZE
6405 #undef ELF_COMMONPAGESIZE
6406 #define ELF_MAXPAGESIZE 0x200000
6407 #define ELF_MINPAGESIZE 0x1000
6408 #define ELF_COMMONPAGESIZE 0x1000
6409 #undef elf_backend_plt_alignment
6410 #define elf_backend_plt_alignment 4
6411 #undef elf_backend_arch_data
6412 #define elf_backend_arch_data &elf_x86_64_arch_bed
6414 #include "elf64-target.h"
6416 /* FreeBSD L1OM support. */
6418 #undef TARGET_LITTLE_SYM
6419 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6420 #undef TARGET_LITTLE_NAME
6421 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6424 #define ELF_OSABI ELFOSABI_FREEBSD
6427 #define elf64_bed elf64_l1om_fbsd_bed
6429 #include "elf64-target.h"
6431 /* Intel K1OM support. */
6434 elf64_k1om_elf_object_p (bfd
*abfd
)
6436 /* Set the right machine number for an K1OM elf64 file. */
6437 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6441 #undef TARGET_LITTLE_SYM
6442 #define TARGET_LITTLE_SYM k1om_elf64_vec
6443 #undef TARGET_LITTLE_NAME
6444 #define TARGET_LITTLE_NAME "elf64-k1om"
6446 #define ELF_ARCH bfd_arch_k1om
6448 #undef ELF_MACHINE_CODE
6449 #define ELF_MACHINE_CODE EM_K1OM
6454 #define elf64_bed elf64_k1om_bed
6456 #undef elf_backend_object_p
6457 #define elf_backend_object_p elf64_k1om_elf_object_p
6459 #undef elf_backend_static_tls_alignment
6461 #undef elf_backend_want_plt_sym
6462 #define elf_backend_want_plt_sym 0
6464 #include "elf64-target.h"
6466 /* FreeBSD K1OM support. */
6468 #undef TARGET_LITTLE_SYM
6469 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6470 #undef TARGET_LITTLE_NAME
6471 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6474 #define ELF_OSABI ELFOSABI_FREEBSD
6477 #define elf64_bed elf64_k1om_fbsd_bed
6479 #include "elf64-target.h"
6481 /* 32bit x86-64 support. */
6483 #undef TARGET_LITTLE_SYM
6484 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6485 #undef TARGET_LITTLE_NAME
6486 #define TARGET_LITTLE_NAME "elf32-x86-64"
6490 #define ELF_ARCH bfd_arch_i386
6492 #undef ELF_MACHINE_CODE
6493 #define ELF_MACHINE_CODE EM_X86_64
6497 #undef elf_backend_object_p
6498 #define elf_backend_object_p \
6499 elf32_x86_64_elf_object_p
6501 #undef elf_backend_bfd_from_remote_memory
6502 #define elf_backend_bfd_from_remote_memory \
6503 _bfd_elf32_bfd_from_remote_memory
6505 #undef elf_backend_size_info
6506 #define elf_backend_size_info \
6507 _bfd_elf32_size_info
6509 #include "elf32-target.h"