1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2014 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, 0, 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 symbol has at least one BND relocation. */
761 bfd_boolean has_bnd_reloc
;
763 /* Information about the second PLT entry. Filled when has_bnd_reloc is
765 union gotplt_union plt_bnd
;
767 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
768 starting at the end of the jump table. */
772 #define elf_x86_64_hash_entry(ent) \
773 ((struct elf_x86_64_link_hash_entry *)(ent))
775 struct elf_x86_64_obj_tdata
777 struct elf_obj_tdata root
;
779 /* tls_type for each local got entry. */
780 char *local_got_tls_type
;
782 /* GOTPLT entries for TLS descriptors. */
783 bfd_vma
*local_tlsdesc_gotent
;
786 #define elf_x86_64_tdata(abfd) \
787 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
789 #define elf_x86_64_local_got_tls_type(abfd) \
790 (elf_x86_64_tdata (abfd)->local_got_tls_type)
792 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
793 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
795 #define is_x86_64_elf(bfd) \
796 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
797 && elf_tdata (bfd) != NULL \
798 && elf_object_id (bfd) == X86_64_ELF_DATA)
801 elf_x86_64_mkobject (bfd
*abfd
)
803 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
807 /* x86-64 ELF linker hash table. */
809 struct elf_x86_64_link_hash_table
811 struct elf_link_hash_table elf
;
813 /* Short-cuts to get to dynamic linker sections. */
816 asection
*plt_eh_frame
;
821 bfd_signed_vma refcount
;
825 /* The amount of space used by the jump slots in the GOT. */
826 bfd_vma sgotplt_jump_table_size
;
828 /* Small local sym cache. */
829 struct sym_cache sym_cache
;
831 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
832 bfd_vma (*r_sym
) (bfd_vma
);
833 unsigned int pointer_r_type
;
834 const char *dynamic_interpreter
;
835 int dynamic_interpreter_size
;
837 /* _TLS_MODULE_BASE_ symbol. */
838 struct bfd_link_hash_entry
*tls_module_base
;
840 /* Used by local STT_GNU_IFUNC symbols. */
841 htab_t loc_hash_table
;
842 void * loc_hash_memory
;
844 /* The offset into splt of the PLT entry for the TLS descriptor
845 resolver. Special values are 0, if not necessary (or not found
846 to be necessary yet), and -1 if needed but not determined
849 /* The offset into sgot of the GOT entry used by the PLT entry
853 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
854 bfd_vma next_jump_slot_index
;
855 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
856 bfd_vma next_irelative_index
;
859 /* Get the x86-64 ELF linker hash table from a link_info structure. */
861 #define elf_x86_64_hash_table(p) \
862 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
863 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
865 #define elf_x86_64_compute_jump_table_size(htab) \
866 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
868 /* Create an entry in an x86-64 ELF linker hash table. */
870 static struct bfd_hash_entry
*
871 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
872 struct bfd_hash_table
*table
,
875 /* Allocate the structure if it has not already been allocated by a
879 entry
= (struct bfd_hash_entry
*)
880 bfd_hash_allocate (table
,
881 sizeof (struct elf_x86_64_link_hash_entry
));
886 /* Call the allocation method of the superclass. */
887 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
890 struct elf_x86_64_link_hash_entry
*eh
;
892 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
893 eh
->dyn_relocs
= NULL
;
894 eh
->tls_type
= GOT_UNKNOWN
;
895 eh
->has_bnd_reloc
= FALSE
;
896 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
897 eh
->tlsdesc_got
= (bfd_vma
) -1;
903 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
904 for local symbol so that we can handle local STT_GNU_IFUNC symbols
905 as global symbol. We reuse indx and dynstr_index for local symbol
906 hash since they aren't used by global symbols in this backend. */
909 elf_x86_64_local_htab_hash (const void *ptr
)
911 struct elf_link_hash_entry
*h
912 = (struct elf_link_hash_entry
*) ptr
;
913 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
916 /* Compare local hash entries. */
919 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
921 struct elf_link_hash_entry
*h1
922 = (struct elf_link_hash_entry
*) ptr1
;
923 struct elf_link_hash_entry
*h2
924 = (struct elf_link_hash_entry
*) ptr2
;
926 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
929 /* Find and/or create a hash entry for local symbol. */
931 static struct elf_link_hash_entry
*
932 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
933 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
936 struct elf_x86_64_link_hash_entry e
, *ret
;
937 asection
*sec
= abfd
->sections
;
938 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
939 htab
->r_sym (rel
->r_info
));
942 e
.elf
.indx
= sec
->id
;
943 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
944 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
945 create
? INSERT
: NO_INSERT
);
952 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
956 ret
= (struct elf_x86_64_link_hash_entry
*)
957 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
958 sizeof (struct elf_x86_64_link_hash_entry
));
961 memset (ret
, 0, sizeof (*ret
));
962 ret
->elf
.indx
= sec
->id
;
963 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
964 ret
->elf
.dynindx
= -1;
970 /* Destroy an X86-64 ELF linker hash table. */
973 elf_x86_64_link_hash_table_free (bfd
*obfd
)
975 struct elf_x86_64_link_hash_table
*htab
976 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
978 if (htab
->loc_hash_table
)
979 htab_delete (htab
->loc_hash_table
);
980 if (htab
->loc_hash_memory
)
981 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
982 _bfd_elf_link_hash_table_free (obfd
);
985 /* Create an X86-64 ELF linker hash table. */
987 static struct bfd_link_hash_table
*
988 elf_x86_64_link_hash_table_create (bfd
*abfd
)
990 struct elf_x86_64_link_hash_table
*ret
;
991 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
993 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
997 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
998 elf_x86_64_link_hash_newfunc
,
999 sizeof (struct elf_x86_64_link_hash_entry
),
1006 if (ABI_64_P (abfd
))
1008 ret
->r_info
= elf64_r_info
;
1009 ret
->r_sym
= elf64_r_sym
;
1010 ret
->pointer_r_type
= R_X86_64_64
;
1011 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1012 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1016 ret
->r_info
= elf32_r_info
;
1017 ret
->r_sym
= elf32_r_sym
;
1018 ret
->pointer_r_type
= R_X86_64_32
;
1019 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1020 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1023 ret
->loc_hash_table
= htab_try_create (1024,
1024 elf_x86_64_local_htab_hash
,
1025 elf_x86_64_local_htab_eq
,
1027 ret
->loc_hash_memory
= objalloc_create ();
1028 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1030 elf_x86_64_link_hash_table_free (abfd
);
1033 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1035 return &ret
->elf
.root
;
1038 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1039 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1043 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1044 struct bfd_link_info
*info
)
1046 struct elf_x86_64_link_hash_table
*htab
;
1048 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1051 htab
= elf_x86_64_hash_table (info
);
1055 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1057 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
1060 || (!info
->shared
&& !htab
->srelbss
))
1063 if (!info
->no_ld_generated_unwind_info
1064 && htab
->plt_eh_frame
== NULL
1065 && htab
->elf
.splt
!= NULL
)
1067 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1068 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1069 | SEC_LINKER_CREATED
);
1071 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1072 if (htab
->plt_eh_frame
== NULL
1073 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1079 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1082 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1083 struct elf_link_hash_entry
*dir
,
1084 struct elf_link_hash_entry
*ind
)
1086 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1088 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1089 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1091 if (!edir
->has_bnd_reloc
)
1092 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1094 if (eind
->dyn_relocs
!= NULL
)
1096 if (edir
->dyn_relocs
!= NULL
)
1098 struct elf_dyn_relocs
**pp
;
1099 struct elf_dyn_relocs
*p
;
1101 /* Add reloc counts against the indirect sym to the direct sym
1102 list. Merge any entries against the same section. */
1103 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1105 struct elf_dyn_relocs
*q
;
1107 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1108 if (q
->sec
== p
->sec
)
1110 q
->pc_count
+= p
->pc_count
;
1111 q
->count
+= p
->count
;
1118 *pp
= edir
->dyn_relocs
;
1121 edir
->dyn_relocs
= eind
->dyn_relocs
;
1122 eind
->dyn_relocs
= NULL
;
1125 if (ind
->root
.type
== bfd_link_hash_indirect
1126 && dir
->got
.refcount
<= 0)
1128 edir
->tls_type
= eind
->tls_type
;
1129 eind
->tls_type
= GOT_UNKNOWN
;
1132 if (ELIMINATE_COPY_RELOCS
1133 && ind
->root
.type
!= bfd_link_hash_indirect
1134 && dir
->dynamic_adjusted
)
1136 /* If called to transfer flags for a weakdef during processing
1137 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1138 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1139 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1140 dir
->ref_regular
|= ind
->ref_regular
;
1141 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1142 dir
->needs_plt
|= ind
->needs_plt
;
1143 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1146 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1150 elf64_x86_64_elf_object_p (bfd
*abfd
)
1152 /* Set the right machine number for an x86-64 elf64 file. */
1153 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1158 elf32_x86_64_elf_object_p (bfd
*abfd
)
1160 /* Set the right machine number for an x86-64 elf32 file. */
1161 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1165 /* Return TRUE if the TLS access code sequence support transition
1169 elf_x86_64_check_tls_transition (bfd
*abfd
,
1170 struct bfd_link_info
*info
,
1173 Elf_Internal_Shdr
*symtab_hdr
,
1174 struct elf_link_hash_entry
**sym_hashes
,
1175 unsigned int r_type
,
1176 const Elf_Internal_Rela
*rel
,
1177 const Elf_Internal_Rela
*relend
)
1180 unsigned long r_symndx
;
1181 bfd_boolean largepic
= FALSE
;
1182 struct elf_link_hash_entry
*h
;
1184 struct elf_x86_64_link_hash_table
*htab
;
1186 /* Get the section contents. */
1187 if (contents
== NULL
)
1189 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1190 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1193 /* FIXME: How to better handle error condition? */
1194 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1197 /* Cache the section contents for elf_link_input_bfd. */
1198 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1202 htab
= elf_x86_64_hash_table (info
);
1203 offset
= rel
->r_offset
;
1206 case R_X86_64_TLSGD
:
1207 case R_X86_64_TLSLD
:
1208 if ((rel
+ 1) >= relend
)
1211 if (r_type
== R_X86_64_TLSGD
)
1213 /* Check transition from GD access model. For 64bit, only
1214 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1215 .word 0x6666; rex64; call __tls_get_addr
1216 can transit to different access model. For 32bit, only
1217 leaq foo@tlsgd(%rip), %rdi
1218 .word 0x6666; rex64; call __tls_get_addr
1219 can transit to different access model. For largepic
1221 leaq foo@tlsgd(%rip), %rdi
1222 movabsq $__tls_get_addr@pltoff, %rax
1226 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1227 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1229 if ((offset
+ 12) > sec
->size
)
1232 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1234 if (!ABI_64_P (abfd
)
1235 || (offset
+ 19) > sec
->size
1237 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1238 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1239 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1244 else if (ABI_64_P (abfd
))
1247 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1253 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1259 /* Check transition from LD access model. Only
1260 leaq foo@tlsld(%rip), %rdi;
1262 can transit to different access model. For largepic
1264 leaq foo@tlsld(%rip), %rdi
1265 movabsq $__tls_get_addr@pltoff, %rax
1269 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1271 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1274 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1277 if (0xe8 != *(contents
+ offset
+ 4))
1279 if (!ABI_64_P (abfd
)
1280 || (offset
+ 19) > sec
->size
1281 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1282 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1289 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1290 if (r_symndx
< symtab_hdr
->sh_info
)
1293 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1294 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1295 may be versioned. */
1297 && h
->root
.root
.string
!= NULL
1299 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1300 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1301 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1302 && (strncmp (h
->root
.root
.string
,
1303 "__tls_get_addr", 14) == 0));
1305 case R_X86_64_GOTTPOFF
:
1306 /* Check transition from IE access model:
1307 mov foo@gottpoff(%rip), %reg
1308 add foo@gottpoff(%rip), %reg
1311 /* Check REX prefix first. */
1312 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1314 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1315 if (val
!= 0x48 && val
!= 0x4c)
1317 /* X32 may have 0x44 REX prefix or no REX prefix. */
1318 if (ABI_64_P (abfd
))
1324 /* X32 may not have any REX prefix. */
1325 if (ABI_64_P (abfd
))
1327 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1331 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1332 if (val
!= 0x8b && val
!= 0x03)
1335 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1336 return (val
& 0xc7) == 5;
1338 case R_X86_64_GOTPC32_TLSDESC
:
1339 /* Check transition from GDesc access model:
1340 leaq x@tlsdesc(%rip), %rax
1342 Make sure it's a leaq adding rip to a 32-bit offset
1343 into any register, although it's probably almost always
1346 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1349 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1350 if ((val
& 0xfb) != 0x48)
1353 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1356 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1357 return (val
& 0xc7) == 0x05;
1359 case R_X86_64_TLSDESC_CALL
:
1360 /* Check transition from GDesc access model:
1361 call *x@tlsdesc(%rax)
1363 if (offset
+ 2 <= sec
->size
)
1365 /* Make sure that it's a call *x@tlsdesc(%rax). */
1366 static const unsigned char call
[] = { 0xff, 0x10 };
1367 return memcmp (contents
+ offset
, call
, 2) == 0;
1377 /* Return TRUE if the TLS access transition is OK or no transition
1378 will be performed. Update R_TYPE if there is a transition. */
1381 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1382 asection
*sec
, bfd_byte
*contents
,
1383 Elf_Internal_Shdr
*symtab_hdr
,
1384 struct elf_link_hash_entry
**sym_hashes
,
1385 unsigned int *r_type
, int tls_type
,
1386 const Elf_Internal_Rela
*rel
,
1387 const Elf_Internal_Rela
*relend
,
1388 struct elf_link_hash_entry
*h
,
1389 unsigned long r_symndx
)
1391 unsigned int from_type
= *r_type
;
1392 unsigned int to_type
= from_type
;
1393 bfd_boolean check
= TRUE
;
1395 /* Skip TLS transition for functions. */
1397 && (h
->type
== STT_FUNC
1398 || h
->type
== STT_GNU_IFUNC
))
1403 case R_X86_64_TLSGD
:
1404 case R_X86_64_GOTPC32_TLSDESC
:
1405 case R_X86_64_TLSDESC_CALL
:
1406 case R_X86_64_GOTTPOFF
:
1407 if (info
->executable
)
1410 to_type
= R_X86_64_TPOFF32
;
1412 to_type
= R_X86_64_GOTTPOFF
;
1415 /* When we are called from elf_x86_64_relocate_section,
1416 CONTENTS isn't NULL and there may be additional transitions
1417 based on TLS_TYPE. */
1418 if (contents
!= NULL
)
1420 unsigned int new_to_type
= to_type
;
1422 if (info
->executable
1425 && tls_type
== GOT_TLS_IE
)
1426 new_to_type
= R_X86_64_TPOFF32
;
1428 if (to_type
== R_X86_64_TLSGD
1429 || to_type
== R_X86_64_GOTPC32_TLSDESC
1430 || to_type
== R_X86_64_TLSDESC_CALL
)
1432 if (tls_type
== GOT_TLS_IE
)
1433 new_to_type
= R_X86_64_GOTTPOFF
;
1436 /* We checked the transition before when we were called from
1437 elf_x86_64_check_relocs. We only want to check the new
1438 transition which hasn't been checked before. */
1439 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1440 to_type
= new_to_type
;
1445 case R_X86_64_TLSLD
:
1446 if (info
->executable
)
1447 to_type
= R_X86_64_TPOFF32
;
1454 /* Return TRUE if there is no transition. */
1455 if (from_type
== to_type
)
1458 /* Check if the transition can be performed. */
1460 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1461 symtab_hdr
, sym_hashes
,
1462 from_type
, rel
, relend
))
1464 reloc_howto_type
*from
, *to
;
1467 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1468 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1471 name
= h
->root
.root
.string
;
1474 struct elf_x86_64_link_hash_table
*htab
;
1476 htab
= elf_x86_64_hash_table (info
);
1481 Elf_Internal_Sym
*isym
;
1483 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1485 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1489 (*_bfd_error_handler
)
1490 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1491 "in section `%A' failed"),
1492 abfd
, sec
, from
->name
, to
->name
, name
,
1493 (unsigned long) rel
->r_offset
);
1494 bfd_set_error (bfd_error_bad_value
);
1502 /* Look through the relocs for a section during the first phase, and
1503 calculate needed space in the global offset table, procedure
1504 linkage table, and dynamic reloc sections. */
1507 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1509 const Elf_Internal_Rela
*relocs
)
1511 struct elf_x86_64_link_hash_table
*htab
;
1512 Elf_Internal_Shdr
*symtab_hdr
;
1513 struct elf_link_hash_entry
**sym_hashes
;
1514 const Elf_Internal_Rela
*rel
;
1515 const Elf_Internal_Rela
*rel_end
;
1518 if (info
->relocatable
)
1521 BFD_ASSERT (is_x86_64_elf (abfd
));
1523 htab
= elf_x86_64_hash_table (info
);
1527 symtab_hdr
= &elf_symtab_hdr (abfd
);
1528 sym_hashes
= elf_sym_hashes (abfd
);
1532 rel_end
= relocs
+ sec
->reloc_count
;
1533 for (rel
= relocs
; rel
< rel_end
; rel
++)
1535 unsigned int r_type
;
1536 unsigned long r_symndx
;
1537 struct elf_link_hash_entry
*h
;
1538 Elf_Internal_Sym
*isym
;
1540 bfd_boolean size_reloc
;
1542 r_symndx
= htab
->r_sym (rel
->r_info
);
1543 r_type
= ELF32_R_TYPE (rel
->r_info
);
1545 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1547 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1552 if (r_symndx
< symtab_hdr
->sh_info
)
1554 /* A local symbol. */
1555 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1560 /* Check relocation against local STT_GNU_IFUNC symbol. */
1561 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1563 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1568 /* Fake a STT_GNU_IFUNC symbol. */
1569 h
->type
= STT_GNU_IFUNC
;
1572 h
->forced_local
= 1;
1573 h
->root
.type
= bfd_link_hash_defined
;
1581 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1582 while (h
->root
.type
== bfd_link_hash_indirect
1583 || h
->root
.type
== bfd_link_hash_warning
)
1584 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1587 /* Check invalid x32 relocations. */
1588 if (!ABI_64_P (abfd
))
1594 case R_X86_64_DTPOFF64
:
1595 case R_X86_64_TPOFF64
:
1597 case R_X86_64_GOTOFF64
:
1598 case R_X86_64_GOT64
:
1599 case R_X86_64_GOTPCREL64
:
1600 case R_X86_64_GOTPC64
:
1601 case R_X86_64_GOTPLT64
:
1602 case R_X86_64_PLTOFF64
:
1605 name
= h
->root
.root
.string
;
1607 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1609 (*_bfd_error_handler
)
1610 (_("%B: relocation %s against symbol `%s' isn't "
1611 "supported in x32 mode"), abfd
,
1612 x86_64_elf_howto_table
[r_type
].name
, name
);
1613 bfd_set_error (bfd_error_bad_value
);
1621 /* Create the ifunc sections for static executables. If we
1622 never see an indirect function symbol nor we are building
1623 a static executable, those sections will be empty and
1624 won't appear in output. */
1630 case R_X86_64_PC32_BND
:
1631 case R_X86_64_PLT32_BND
:
1632 /* MPX PLT is supported only if elf_x86_64_arch_bed
1633 is used in 64-bit mode. */
1635 && (get_elf_x86_64_backend_data (abfd
)
1636 == &elf_x86_64_arch_bed
))
1638 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= TRUE
;
1640 /* Create the second PLT for Intel MPX support. */
1641 if (htab
->plt_bnd
== NULL
)
1643 unsigned int plt_bnd_align
;
1644 const struct elf_backend_data
*bed
;
1646 bed
= get_elf_backend_data (info
->output_bfd
);
1647 switch (sizeof (elf_x86_64_bnd_plt2_entry
))
1659 if (htab
->elf
.dynobj
== NULL
)
1660 htab
->elf
.dynobj
= abfd
;
1662 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1664 (bed
->dynamic_sec_flags
1669 if (htab
->plt_bnd
== NULL
1670 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1682 case R_X86_64_PLT32
:
1683 case R_X86_64_GOTPCREL
:
1684 case R_X86_64_GOTPCREL64
:
1685 if (htab
->elf
.dynobj
== NULL
)
1686 htab
->elf
.dynobj
= abfd
;
1687 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1692 /* It is referenced by a non-shared object. */
1694 h
->root
.non_ir_ref
= 1;
1697 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1698 symtab_hdr
, sym_hashes
,
1699 &r_type
, GOT_UNKNOWN
,
1700 rel
, rel_end
, h
, r_symndx
))
1705 case R_X86_64_TLSLD
:
1706 htab
->tls_ld_got
.refcount
+= 1;
1709 case R_X86_64_TPOFF32
:
1710 if (!info
->executable
&& ABI_64_P (abfd
))
1713 name
= h
->root
.root
.string
;
1715 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1717 (*_bfd_error_handler
)
1718 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1720 x86_64_elf_howto_table
[r_type
].name
, name
);
1721 bfd_set_error (bfd_error_bad_value
);
1726 case R_X86_64_GOTTPOFF
:
1727 if (!info
->executable
)
1728 info
->flags
|= DF_STATIC_TLS
;
1731 case R_X86_64_GOT32
:
1732 case R_X86_64_GOTPCREL
:
1733 case R_X86_64_TLSGD
:
1734 case R_X86_64_GOT64
:
1735 case R_X86_64_GOTPCREL64
:
1736 case R_X86_64_GOTPLT64
:
1737 case R_X86_64_GOTPC32_TLSDESC
:
1738 case R_X86_64_TLSDESC_CALL
:
1739 /* This symbol requires a global offset table entry. */
1741 int tls_type
, old_tls_type
;
1745 default: tls_type
= GOT_NORMAL
; break;
1746 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1747 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1748 case R_X86_64_GOTPC32_TLSDESC
:
1749 case R_X86_64_TLSDESC_CALL
:
1750 tls_type
= GOT_TLS_GDESC
; break;
1755 if (r_type
== R_X86_64_GOTPLT64
)
1757 /* This relocation indicates that we also need
1758 a PLT entry, as this is a function. We don't need
1759 a PLT entry for local symbols. */
1761 h
->plt
.refcount
+= 1;
1763 h
->got
.refcount
+= 1;
1764 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1768 bfd_signed_vma
*local_got_refcounts
;
1770 /* This is a global offset table entry for a local symbol. */
1771 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1772 if (local_got_refcounts
== NULL
)
1776 size
= symtab_hdr
->sh_info
;
1777 size
*= sizeof (bfd_signed_vma
)
1778 + sizeof (bfd_vma
) + sizeof (char);
1779 local_got_refcounts
= ((bfd_signed_vma
*)
1780 bfd_zalloc (abfd
, size
));
1781 if (local_got_refcounts
== NULL
)
1783 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1784 elf_x86_64_local_tlsdesc_gotent (abfd
)
1785 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1786 elf_x86_64_local_got_tls_type (abfd
)
1787 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1789 local_got_refcounts
[r_symndx
] += 1;
1791 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1794 /* If a TLS symbol is accessed using IE at least once,
1795 there is no point to use dynamic model for it. */
1796 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1797 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1798 || tls_type
!= GOT_TLS_IE
))
1800 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1801 tls_type
= old_tls_type
;
1802 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1803 && GOT_TLS_GD_ANY_P (tls_type
))
1804 tls_type
|= old_tls_type
;
1808 name
= h
->root
.root
.string
;
1810 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1812 (*_bfd_error_handler
)
1813 (_("%B: '%s' accessed both as normal and thread local symbol"),
1815 bfd_set_error (bfd_error_bad_value
);
1820 if (old_tls_type
!= tls_type
)
1823 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1825 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1830 case R_X86_64_GOTOFF64
:
1831 case R_X86_64_GOTPC32
:
1832 case R_X86_64_GOTPC64
:
1834 if (htab
->elf
.sgot
== NULL
)
1836 if (htab
->elf
.dynobj
== NULL
)
1837 htab
->elf
.dynobj
= abfd
;
1838 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1844 case R_X86_64_PLT32
:
1845 case R_X86_64_PLT32_BND
:
1846 /* This symbol requires a procedure linkage table entry. We
1847 actually build the entry in adjust_dynamic_symbol,
1848 because this might be a case of linking PIC code which is
1849 never referenced by a dynamic object, in which case we
1850 don't need to generate a procedure linkage table entry
1853 /* If this is a local symbol, we resolve it directly without
1854 creating a procedure linkage table entry. */
1859 h
->plt
.refcount
+= 1;
1862 case R_X86_64_PLTOFF64
:
1863 /* This tries to form the 'address' of a function relative
1864 to GOT. For global symbols we need a PLT entry. */
1868 h
->plt
.refcount
+= 1;
1872 case R_X86_64_SIZE32
:
1873 case R_X86_64_SIZE64
:
1878 if (!ABI_64_P (abfd
))
1883 /* Let's help debug shared library creation. These relocs
1884 cannot be used in shared libs. Don't error out for
1885 sections we don't care about, such as debug sections or
1886 non-constant sections. */
1888 && (sec
->flags
& SEC_ALLOC
) != 0
1889 && (sec
->flags
& SEC_READONLY
) != 0)
1892 name
= h
->root
.root
.string
;
1894 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1895 (*_bfd_error_handler
)
1896 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1897 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1898 bfd_set_error (bfd_error_bad_value
);
1906 case R_X86_64_PC32_BND
:
1910 if (h
!= NULL
&& info
->executable
)
1912 /* If this reloc is in a read-only section, we might
1913 need a copy reloc. We can't check reliably at this
1914 stage whether the section is read-only, as input
1915 sections have not yet been mapped to output sections.
1916 Tentatively set the flag for now, and correct in
1917 adjust_dynamic_symbol. */
1920 /* We may need a .plt entry if the function this reloc
1921 refers to is in a shared lib. */
1922 h
->plt
.refcount
+= 1;
1923 if (r_type
!= R_X86_64_PC32
1924 && r_type
!= R_X86_64_PC32_BND
1925 && r_type
!= R_X86_64_PC64
)
1926 h
->pointer_equality_needed
= 1;
1931 /* If we are creating a shared library, and this is a reloc
1932 against a global symbol, or a non PC relative reloc
1933 against a local symbol, then we need to copy the reloc
1934 into the shared library. However, if we are linking with
1935 -Bsymbolic, we do not need to copy a reloc against a
1936 global symbol which is defined in an object we are
1937 including in the link (i.e., DEF_REGULAR is set). At
1938 this point we have not seen all the input files, so it is
1939 possible that DEF_REGULAR is not set now but will be set
1940 later (it is never cleared). In case of a weak definition,
1941 DEF_REGULAR may be cleared later by a strong definition in
1942 a shared library. We account for that possibility below by
1943 storing information in the relocs_copied field of the hash
1944 table entry. A similar situation occurs when creating
1945 shared libraries and symbol visibility changes render the
1948 If on the other hand, we are creating an executable, we
1949 may need to keep relocations for symbols satisfied by a
1950 dynamic library if we manage to avoid copy relocs for the
1953 && (sec
->flags
& SEC_ALLOC
) != 0
1954 && (! IS_X86_64_PCREL_TYPE (r_type
)
1956 && (! SYMBOLIC_BIND (info
, h
)
1957 || h
->root
.type
== bfd_link_hash_defweak
1958 || !h
->def_regular
))))
1959 || (ELIMINATE_COPY_RELOCS
1961 && (sec
->flags
& SEC_ALLOC
) != 0
1963 && (h
->root
.type
== bfd_link_hash_defweak
1964 || !h
->def_regular
)))
1966 struct elf_dyn_relocs
*p
;
1967 struct elf_dyn_relocs
**head
;
1969 /* We must copy these reloc types into the output file.
1970 Create a reloc section in dynobj and make room for
1974 if (htab
->elf
.dynobj
== NULL
)
1975 htab
->elf
.dynobj
= abfd
;
1977 sreloc
= _bfd_elf_make_dynamic_reloc_section
1978 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1979 abfd
, /*rela?*/ TRUE
);
1985 /* If this is a global symbol, we count the number of
1986 relocations we need for this symbol. */
1989 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1993 /* Track dynamic relocs needed for local syms too.
1994 We really need local syms available to do this
1999 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2004 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2008 /* Beware of type punned pointers vs strict aliasing
2010 vpp
= &(elf_section_data (s
)->local_dynrel
);
2011 head
= (struct elf_dyn_relocs
**)vpp
;
2015 if (p
== NULL
|| p
->sec
!= sec
)
2017 bfd_size_type amt
= sizeof *p
;
2019 p
= ((struct elf_dyn_relocs
*)
2020 bfd_alloc (htab
->elf
.dynobj
, amt
));
2031 /* Count size relocation as PC-relative relocation. */
2032 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2037 /* This relocation describes the C++ object vtable hierarchy.
2038 Reconstruct it for later use during GC. */
2039 case R_X86_64_GNU_VTINHERIT
:
2040 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2044 /* This relocation describes which C++ vtable entries are actually
2045 used. Record for later use during GC. */
2046 case R_X86_64_GNU_VTENTRY
:
2047 BFD_ASSERT (h
!= NULL
);
2049 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2061 /* Return the section that should be marked against GC for a given
2065 elf_x86_64_gc_mark_hook (asection
*sec
,
2066 struct bfd_link_info
*info
,
2067 Elf_Internal_Rela
*rel
,
2068 struct elf_link_hash_entry
*h
,
2069 Elf_Internal_Sym
*sym
)
2072 switch (ELF32_R_TYPE (rel
->r_info
))
2074 case R_X86_64_GNU_VTINHERIT
:
2075 case R_X86_64_GNU_VTENTRY
:
2079 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2082 /* Update the got entry reference counts for the section being removed. */
2085 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2087 const Elf_Internal_Rela
*relocs
)
2089 struct elf_x86_64_link_hash_table
*htab
;
2090 Elf_Internal_Shdr
*symtab_hdr
;
2091 struct elf_link_hash_entry
**sym_hashes
;
2092 bfd_signed_vma
*local_got_refcounts
;
2093 const Elf_Internal_Rela
*rel
, *relend
;
2095 if (info
->relocatable
)
2098 htab
= elf_x86_64_hash_table (info
);
2102 elf_section_data (sec
)->local_dynrel
= NULL
;
2104 symtab_hdr
= &elf_symtab_hdr (abfd
);
2105 sym_hashes
= elf_sym_hashes (abfd
);
2106 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2108 htab
= elf_x86_64_hash_table (info
);
2109 relend
= relocs
+ sec
->reloc_count
;
2110 for (rel
= relocs
; rel
< relend
; rel
++)
2112 unsigned long r_symndx
;
2113 unsigned int r_type
;
2114 struct elf_link_hash_entry
*h
= NULL
;
2116 r_symndx
= htab
->r_sym (rel
->r_info
);
2117 if (r_symndx
>= symtab_hdr
->sh_info
)
2119 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2120 while (h
->root
.type
== bfd_link_hash_indirect
2121 || h
->root
.type
== bfd_link_hash_warning
)
2122 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2126 /* A local symbol. */
2127 Elf_Internal_Sym
*isym
;
2129 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2132 /* Check relocation against local STT_GNU_IFUNC symbol. */
2134 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2136 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2144 struct elf_x86_64_link_hash_entry
*eh
;
2145 struct elf_dyn_relocs
**pp
;
2146 struct elf_dyn_relocs
*p
;
2148 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2150 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2153 /* Everything must go for SEC. */
2159 r_type
= ELF32_R_TYPE (rel
->r_info
);
2160 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2161 symtab_hdr
, sym_hashes
,
2162 &r_type
, GOT_UNKNOWN
,
2163 rel
, relend
, h
, r_symndx
))
2168 case R_X86_64_TLSLD
:
2169 if (htab
->tls_ld_got
.refcount
> 0)
2170 htab
->tls_ld_got
.refcount
-= 1;
2173 case R_X86_64_TLSGD
:
2174 case R_X86_64_GOTPC32_TLSDESC
:
2175 case R_X86_64_TLSDESC_CALL
:
2176 case R_X86_64_GOTTPOFF
:
2177 case R_X86_64_GOT32
:
2178 case R_X86_64_GOTPCREL
:
2179 case R_X86_64_GOT64
:
2180 case R_X86_64_GOTPCREL64
:
2181 case R_X86_64_GOTPLT64
:
2184 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
2185 h
->plt
.refcount
-= 1;
2186 if (h
->got
.refcount
> 0)
2187 h
->got
.refcount
-= 1;
2188 if (h
->type
== STT_GNU_IFUNC
)
2190 if (h
->plt
.refcount
> 0)
2191 h
->plt
.refcount
-= 1;
2194 else if (local_got_refcounts
!= NULL
)
2196 if (local_got_refcounts
[r_symndx
] > 0)
2197 local_got_refcounts
[r_symndx
] -= 1;
2209 case R_X86_64_PC32_BND
:
2211 case R_X86_64_SIZE32
:
2212 case R_X86_64_SIZE64
:
2214 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2218 case R_X86_64_PLT32
:
2219 case R_X86_64_PLT32_BND
:
2220 case R_X86_64_PLTOFF64
:
2223 if (h
->plt
.refcount
> 0)
2224 h
->plt
.refcount
-= 1;
2236 /* Adjust a symbol defined by a dynamic object and referenced by a
2237 regular object. The current definition is in some section of the
2238 dynamic object, but we're not including those sections. We have to
2239 change the definition to something the rest of the link can
2243 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2244 struct elf_link_hash_entry
*h
)
2246 struct elf_x86_64_link_hash_table
*htab
;
2248 struct elf_x86_64_link_hash_entry
*eh
;
2249 struct elf_dyn_relocs
*p
;
2251 /* STT_GNU_IFUNC symbol must go through PLT. */
2252 if (h
->type
== STT_GNU_IFUNC
)
2254 /* All local STT_GNU_IFUNC references must be treate as local
2255 calls via local PLT. */
2257 && SYMBOL_CALLS_LOCAL (info
, h
))
2259 bfd_size_type pc_count
= 0, count
= 0;
2260 struct elf_dyn_relocs
**pp
;
2262 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2263 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2265 pc_count
+= p
->pc_count
;
2266 p
->count
-= p
->pc_count
;
2275 if (pc_count
|| count
)
2279 if (h
->plt
.refcount
<= 0)
2280 h
->plt
.refcount
= 1;
2282 h
->plt
.refcount
+= 1;
2286 if (h
->plt
.refcount
<= 0)
2288 h
->plt
.offset
= (bfd_vma
) -1;
2294 /* If this is a function, put it in the procedure linkage table. We
2295 will fill in the contents of the procedure linkage table later,
2296 when we know the address of the .got section. */
2297 if (h
->type
== STT_FUNC
2300 if (h
->plt
.refcount
<= 0
2301 || SYMBOL_CALLS_LOCAL (info
, h
)
2302 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2303 && h
->root
.type
== bfd_link_hash_undefweak
))
2305 /* This case can occur if we saw a PLT32 reloc in an input
2306 file, but the symbol was never referred to by a dynamic
2307 object, or if all references were garbage collected. In
2308 such a case, we don't actually need to build a procedure
2309 linkage table, and we can just do a PC32 reloc instead. */
2310 h
->plt
.offset
= (bfd_vma
) -1;
2317 /* It's possible that we incorrectly decided a .plt reloc was
2318 needed for an R_X86_64_PC32 reloc to a non-function sym in
2319 check_relocs. We can't decide accurately between function and
2320 non-function syms in check-relocs; Objects loaded later in
2321 the link may change h->type. So fix it now. */
2322 h
->plt
.offset
= (bfd_vma
) -1;
2324 /* If this is a weak symbol, and there is a real definition, the
2325 processor independent code will have arranged for us to see the
2326 real definition first, and we can just use the same value. */
2327 if (h
->u
.weakdef
!= NULL
)
2329 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2330 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2331 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2332 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2333 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2334 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2338 /* This is a reference to a symbol defined by a dynamic object which
2339 is not a function. */
2341 /* If we are creating a shared library, we must presume that the
2342 only references to the symbol are via the global offset table.
2343 For such cases we need not do anything here; the relocations will
2344 be handled correctly by relocate_section. */
2348 /* If there are no references to this symbol that do not use the
2349 GOT, we don't need to generate a copy reloc. */
2350 if (!h
->non_got_ref
)
2353 /* If -z nocopyreloc was given, we won't generate them either. */
2354 if (info
->nocopyreloc
)
2360 if (ELIMINATE_COPY_RELOCS
)
2362 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2363 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2365 s
= p
->sec
->output_section
;
2366 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2370 /* If we didn't find any dynamic relocs in read-only sections, then
2371 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2379 /* We must allocate the symbol in our .dynbss section, which will
2380 become part of the .bss section of the executable. There will be
2381 an entry for this symbol in the .dynsym section. The dynamic
2382 object will contain position independent code, so all references
2383 from the dynamic object to this symbol will go through the global
2384 offset table. The dynamic linker will use the .dynsym entry to
2385 determine the address it must put in the global offset table, so
2386 both the dynamic object and the regular object will refer to the
2387 same memory location for the variable. */
2389 htab
= elf_x86_64_hash_table (info
);
2393 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2394 to copy the initial value out of the dynamic object and into the
2395 runtime process image. */
2396 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2398 const struct elf_backend_data
*bed
;
2399 bed
= get_elf_backend_data (info
->output_bfd
);
2400 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2406 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2409 /* Allocate space in .plt, .got and associated reloc sections for
2413 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2415 struct bfd_link_info
*info
;
2416 struct elf_x86_64_link_hash_table
*htab
;
2417 struct elf_x86_64_link_hash_entry
*eh
;
2418 struct elf_dyn_relocs
*p
;
2419 const struct elf_backend_data
*bed
;
2420 unsigned int plt_entry_size
;
2422 if (h
->root
.type
== bfd_link_hash_indirect
)
2425 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2427 info
= (struct bfd_link_info
*) inf
;
2428 htab
= elf_x86_64_hash_table (info
);
2431 bed
= get_elf_backend_data (info
->output_bfd
);
2432 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2434 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2435 here if it is defined and referenced in a non-shared object. */
2436 if (h
->type
== STT_GNU_IFUNC
2439 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2445 asection
*s
= htab
->plt_bnd
;
2446 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2448 /* Use the .plt.bnd section if it is created. */
2449 eh
->plt_bnd
.offset
= s
->size
;
2451 /* Make room for this entry in the .plt.bnd section. */
2452 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2460 else if (htab
->elf
.dynamic_sections_created
2461 && h
->plt
.refcount
> 0)
2463 /* Make sure this symbol is output as a dynamic symbol.
2464 Undefined weak syms won't yet be marked as dynamic. */
2465 if (h
->dynindx
== -1
2466 && !h
->forced_local
)
2468 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2473 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2475 asection
*s
= htab
->elf
.splt
;
2476 asection
*bnd_s
= htab
->plt_bnd
;
2478 /* If this is the first .plt entry, make room for the special
2481 s
->size
= plt_entry_size
;
2483 h
->plt
.offset
= s
->size
;
2485 eh
->plt_bnd
.offset
= bnd_s
->size
;
2487 /* If this symbol is not defined in a regular file, and we are
2488 not generating a shared library, then set the symbol to this
2489 location in the .plt. This is required to make function
2490 pointers compare as equal between the normal executable and
2491 the shared library. */
2497 /* We need to make a call to the entry of the second
2498 PLT instead of regular PLT entry. */
2499 h
->root
.u
.def
.section
= bnd_s
;
2500 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2504 h
->root
.u
.def
.section
= s
;
2505 h
->root
.u
.def
.value
= h
->plt
.offset
;
2509 /* Make room for this entry. */
2510 s
->size
+= plt_entry_size
;
2513 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
)
2514 == sizeof (elf_x86_64_legacy_plt2_entry
));
2515 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2518 /* We also need to make an entry in the .got.plt section, which
2519 will be placed in the .got section by the linker script. */
2520 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2522 /* We also need to make an entry in the .rela.plt section. */
2523 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2524 htab
->elf
.srelplt
->reloc_count
++;
2528 h
->plt
.offset
= (bfd_vma
) -1;
2534 h
->plt
.offset
= (bfd_vma
) -1;
2538 eh
->tlsdesc_got
= (bfd_vma
) -1;
2540 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2541 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2542 if (h
->got
.refcount
> 0
2545 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2547 h
->got
.offset
= (bfd_vma
) -1;
2549 else if (h
->got
.refcount
> 0)
2553 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2555 /* Make sure this symbol is output as a dynamic symbol.
2556 Undefined weak syms won't yet be marked as dynamic. */
2557 if (h
->dynindx
== -1
2558 && !h
->forced_local
)
2560 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2564 if (GOT_TLS_GDESC_P (tls_type
))
2566 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2567 - elf_x86_64_compute_jump_table_size (htab
);
2568 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2569 h
->got
.offset
= (bfd_vma
) -2;
2571 if (! GOT_TLS_GDESC_P (tls_type
)
2572 || GOT_TLS_GD_P (tls_type
))
2575 h
->got
.offset
= s
->size
;
2576 s
->size
+= GOT_ENTRY_SIZE
;
2577 if (GOT_TLS_GD_P (tls_type
))
2578 s
->size
+= GOT_ENTRY_SIZE
;
2580 dyn
= htab
->elf
.dynamic_sections_created
;
2581 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2583 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2584 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2585 || tls_type
== GOT_TLS_IE
)
2586 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2587 else if (GOT_TLS_GD_P (tls_type
))
2588 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2589 else if (! GOT_TLS_GDESC_P (tls_type
)
2590 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2591 || h
->root
.type
!= bfd_link_hash_undefweak
)
2593 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2594 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2595 if (GOT_TLS_GDESC_P (tls_type
))
2597 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2598 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2602 h
->got
.offset
= (bfd_vma
) -1;
2604 if (eh
->dyn_relocs
== NULL
)
2607 /* In the shared -Bsymbolic case, discard space allocated for
2608 dynamic pc-relative relocs against symbols which turn out to be
2609 defined in regular objects. For the normal shared case, discard
2610 space for pc-relative relocs that have become local due to symbol
2611 visibility changes. */
2615 /* Relocs that use pc_count are those that appear on a call
2616 insn, or certain REL relocs that can generated via assembly.
2617 We want calls to protected symbols to resolve directly to the
2618 function rather than going via the plt. If people want
2619 function pointer comparisons to work as expected then they
2620 should avoid writing weird assembly. */
2621 if (SYMBOL_CALLS_LOCAL (info
, h
))
2623 struct elf_dyn_relocs
**pp
;
2625 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2627 p
->count
-= p
->pc_count
;
2636 /* Also discard relocs on undefined weak syms with non-default
2638 if (eh
->dyn_relocs
!= NULL
2639 && h
->root
.type
== bfd_link_hash_undefweak
)
2641 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2642 eh
->dyn_relocs
= NULL
;
2644 /* Make sure undefined weak symbols are output as a dynamic
2646 else if (h
->dynindx
== -1
2647 && ! h
->forced_local
2648 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2653 else if (ELIMINATE_COPY_RELOCS
)
2655 /* For the non-shared case, discard space for relocs against
2656 symbols which turn out to need copy relocs or are not
2662 || (htab
->elf
.dynamic_sections_created
2663 && (h
->root
.type
== bfd_link_hash_undefweak
2664 || h
->root
.type
== bfd_link_hash_undefined
))))
2666 /* Make sure this symbol is output as a dynamic symbol.
2667 Undefined weak syms won't yet be marked as dynamic. */
2668 if (h
->dynindx
== -1
2669 && ! h
->forced_local
2670 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2673 /* If that succeeded, we know we'll be keeping all the
2675 if (h
->dynindx
!= -1)
2679 eh
->dyn_relocs
= NULL
;
2684 /* Finally, allocate space. */
2685 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2689 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2691 BFD_ASSERT (sreloc
!= NULL
);
2693 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2699 /* Allocate space in .plt, .got and associated reloc sections for
2700 local dynamic relocs. */
2703 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2705 struct elf_link_hash_entry
*h
2706 = (struct elf_link_hash_entry
*) *slot
;
2708 if (h
->type
!= STT_GNU_IFUNC
2712 || h
->root
.type
!= bfd_link_hash_defined
)
2715 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2718 /* Find any dynamic relocs that apply to read-only sections. */
2721 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2724 struct elf_x86_64_link_hash_entry
*eh
;
2725 struct elf_dyn_relocs
*p
;
2727 /* Skip local IFUNC symbols. */
2728 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2731 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2732 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2734 asection
*s
= p
->sec
->output_section
;
2736 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2738 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2740 info
->flags
|= DF_TEXTREL
;
2742 if (info
->warn_shared_textrel
&& info
->shared
)
2743 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2744 p
->sec
->owner
, h
->root
.root
.string
,
2747 /* Not an error, just cut short the traversal. */
2755 mov foo@GOTPCREL(%rip), %reg
2758 with the local symbol, foo. */
2761 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2762 struct bfd_link_info
*link_info
)
2764 Elf_Internal_Shdr
*symtab_hdr
;
2765 Elf_Internal_Rela
*internal_relocs
;
2766 Elf_Internal_Rela
*irel
, *irelend
;
2768 struct elf_x86_64_link_hash_table
*htab
;
2769 bfd_boolean changed_contents
;
2770 bfd_boolean changed_relocs
;
2771 bfd_signed_vma
*local_got_refcounts
;
2773 /* Don't even try to convert non-ELF outputs. */
2774 if (!is_elf_hash_table (link_info
->hash
))
2777 /* Nothing to do if there are no codes, no relocations or no output. */
2778 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2779 || sec
->reloc_count
== 0
2780 || bfd_is_abs_section (sec
->output_section
))
2783 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2785 /* Load the relocations for this section. */
2786 internal_relocs
= (_bfd_elf_link_read_relocs
2787 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2788 link_info
->keep_memory
));
2789 if (internal_relocs
== NULL
)
2792 htab
= elf_x86_64_hash_table (link_info
);
2793 changed_contents
= FALSE
;
2794 changed_relocs
= FALSE
;
2795 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2797 /* Get the section contents. */
2798 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2799 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2802 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2806 irelend
= internal_relocs
+ sec
->reloc_count
;
2807 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2809 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2810 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2812 struct elf_link_hash_entry
*h
;
2814 if (r_type
!= R_X86_64_GOTPCREL
)
2817 /* Get the symbol referred to by the reloc. */
2818 if (r_symndx
< symtab_hdr
->sh_info
)
2820 Elf_Internal_Sym
*isym
;
2822 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2825 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2826 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2827 && bfd_get_8 (input_bfd
,
2828 contents
+ irel
->r_offset
- 2) == 0x8b)
2830 bfd_put_8 (output_bfd
, 0x8d,
2831 contents
+ irel
->r_offset
- 2);
2832 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2833 if (local_got_refcounts
!= NULL
2834 && local_got_refcounts
[r_symndx
] > 0)
2835 local_got_refcounts
[r_symndx
] -= 1;
2836 changed_contents
= TRUE
;
2837 changed_relocs
= TRUE
;
2842 indx
= r_symndx
- symtab_hdr
->sh_info
;
2843 h
= elf_sym_hashes (abfd
)[indx
];
2844 BFD_ASSERT (h
!= NULL
);
2846 while (h
->root
.type
== bfd_link_hash_indirect
2847 || h
->root
.type
== bfd_link_hash_warning
)
2848 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2850 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2851 avoid optimizing _DYNAMIC since ld.so may use its link-time
2854 && h
->type
!= STT_GNU_IFUNC
2855 && h
!= htab
->elf
.hdynamic
2856 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2857 && bfd_get_8 (input_bfd
,
2858 contents
+ irel
->r_offset
- 2) == 0x8b)
2860 bfd_put_8 (output_bfd
, 0x8d,
2861 contents
+ irel
->r_offset
- 2);
2862 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2863 if (h
->got
.refcount
> 0)
2864 h
->got
.refcount
-= 1;
2865 changed_contents
= TRUE
;
2866 changed_relocs
= TRUE
;
2870 if (contents
!= NULL
2871 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2873 if (!changed_contents
&& !link_info
->keep_memory
)
2877 /* Cache the section contents for elf_link_input_bfd. */
2878 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2882 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2884 if (!changed_relocs
)
2885 free (internal_relocs
);
2887 elf_section_data (sec
)->relocs
= internal_relocs
;
2893 if (contents
!= NULL
2894 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2896 if (internal_relocs
!= NULL
2897 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2898 free (internal_relocs
);
2902 /* Set the sizes of the dynamic sections. */
2905 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2906 struct bfd_link_info
*info
)
2908 struct elf_x86_64_link_hash_table
*htab
;
2913 const struct elf_backend_data
*bed
;
2915 htab
= elf_x86_64_hash_table (info
);
2918 bed
= get_elf_backend_data (output_bfd
);
2920 dynobj
= htab
->elf
.dynobj
;
2924 if (htab
->elf
.dynamic_sections_created
)
2926 /* Set the contents of the .interp section to the interpreter. */
2927 if (info
->executable
)
2929 s
= bfd_get_linker_section (dynobj
, ".interp");
2932 s
->size
= htab
->dynamic_interpreter_size
;
2933 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2937 /* Set up .got offsets for local syms, and space for local dynamic
2939 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2941 bfd_signed_vma
*local_got
;
2942 bfd_signed_vma
*end_local_got
;
2943 char *local_tls_type
;
2944 bfd_vma
*local_tlsdesc_gotent
;
2945 bfd_size_type locsymcount
;
2946 Elf_Internal_Shdr
*symtab_hdr
;
2949 if (! is_x86_64_elf (ibfd
))
2952 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2954 struct elf_dyn_relocs
*p
;
2956 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2959 for (p
= (struct elf_dyn_relocs
*)
2960 (elf_section_data (s
)->local_dynrel
);
2964 if (!bfd_is_abs_section (p
->sec
)
2965 && bfd_is_abs_section (p
->sec
->output_section
))
2967 /* Input section has been discarded, either because
2968 it is a copy of a linkonce section or due to
2969 linker script /DISCARD/, so we'll be discarding
2972 else if (p
->count
!= 0)
2974 srel
= elf_section_data (p
->sec
)->sreloc
;
2975 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2976 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2977 && (info
->flags
& DF_TEXTREL
) == 0)
2979 info
->flags
|= DF_TEXTREL
;
2980 if (info
->warn_shared_textrel
&& info
->shared
)
2981 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2982 p
->sec
->owner
, p
->sec
);
2988 local_got
= elf_local_got_refcounts (ibfd
);
2992 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2993 locsymcount
= symtab_hdr
->sh_info
;
2994 end_local_got
= local_got
+ locsymcount
;
2995 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2996 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2998 srel
= htab
->elf
.srelgot
;
2999 for (; local_got
< end_local_got
;
3000 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3002 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3005 if (GOT_TLS_GDESC_P (*local_tls_type
))
3007 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3008 - elf_x86_64_compute_jump_table_size (htab
);
3009 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3010 *local_got
= (bfd_vma
) -2;
3012 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3013 || GOT_TLS_GD_P (*local_tls_type
))
3015 *local_got
= s
->size
;
3016 s
->size
+= GOT_ENTRY_SIZE
;
3017 if (GOT_TLS_GD_P (*local_tls_type
))
3018 s
->size
+= GOT_ENTRY_SIZE
;
3021 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3022 || *local_tls_type
== GOT_TLS_IE
)
3024 if (GOT_TLS_GDESC_P (*local_tls_type
))
3026 htab
->elf
.srelplt
->size
3027 += bed
->s
->sizeof_rela
;
3028 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3030 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3031 || GOT_TLS_GD_P (*local_tls_type
))
3032 srel
->size
+= bed
->s
->sizeof_rela
;
3036 *local_got
= (bfd_vma
) -1;
3040 if (htab
->tls_ld_got
.refcount
> 0)
3042 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3044 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3045 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3046 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3049 htab
->tls_ld_got
.offset
= -1;
3051 /* Allocate global sym .plt and .got entries, and space for global
3052 sym dynamic relocs. */
3053 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3056 /* Allocate .plt and .got entries, and space for local symbols. */
3057 htab_traverse (htab
->loc_hash_table
,
3058 elf_x86_64_allocate_local_dynrelocs
,
3061 /* For every jump slot reserved in the sgotplt, reloc_count is
3062 incremented. However, when we reserve space for TLS descriptors,
3063 it's not incremented, so in order to compute the space reserved
3064 for them, it suffices to multiply the reloc count by the jump
3067 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3068 so that R_X86_64_IRELATIVE entries come last. */
3069 if (htab
->elf
.srelplt
)
3071 htab
->sgotplt_jump_table_size
3072 = elf_x86_64_compute_jump_table_size (htab
);
3073 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3075 else if (htab
->elf
.irelplt
)
3076 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3078 if (htab
->tlsdesc_plt
)
3080 /* If we're not using lazy TLS relocations, don't generate the
3081 PLT and GOT entries they require. */
3082 if ((info
->flags
& DF_BIND_NOW
))
3083 htab
->tlsdesc_plt
= 0;
3086 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3087 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3088 /* Reserve room for the initial entry.
3089 FIXME: we could probably do away with it in this case. */
3090 if (htab
->elf
.splt
->size
== 0)
3091 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3092 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3093 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3097 if (htab
->elf
.sgotplt
)
3099 /* Don't allocate .got.plt section if there are no GOT nor PLT
3100 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3101 if ((htab
->elf
.hgot
== NULL
3102 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3103 && (htab
->elf
.sgotplt
->size
3104 == get_elf_backend_data (output_bfd
)->got_header_size
)
3105 && (htab
->elf
.splt
== NULL
3106 || htab
->elf
.splt
->size
== 0)
3107 && (htab
->elf
.sgot
== NULL
3108 || htab
->elf
.sgot
->size
== 0)
3109 && (htab
->elf
.iplt
== NULL
3110 || htab
->elf
.iplt
->size
== 0)
3111 && (htab
->elf
.igotplt
== NULL
3112 || htab
->elf
.igotplt
->size
== 0))
3113 htab
->elf
.sgotplt
->size
= 0;
3116 if (htab
->plt_eh_frame
!= NULL
3117 && htab
->elf
.splt
!= NULL
3118 && htab
->elf
.splt
->size
!= 0
3119 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3120 && _bfd_elf_eh_frame_present (info
))
3122 const struct elf_x86_64_backend_data
*arch_data
3123 = get_elf_x86_64_arch_data (bed
);
3124 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3127 /* We now have determined the sizes of the various dynamic sections.
3128 Allocate memory for them. */
3130 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3132 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3135 if (s
== htab
->elf
.splt
3136 || s
== htab
->elf
.sgot
3137 || s
== htab
->elf
.sgotplt
3138 || s
== htab
->elf
.iplt
3139 || s
== htab
->elf
.igotplt
3140 || s
== htab
->plt_bnd
3141 || s
== htab
->plt_eh_frame
3142 || s
== htab
->sdynbss
)
3144 /* Strip this section if we don't need it; see the
3147 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3149 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3152 /* We use the reloc_count field as a counter if we need
3153 to copy relocs into the output file. */
3154 if (s
!= htab
->elf
.srelplt
)
3159 /* It's not one of our sections, so don't allocate space. */
3165 /* If we don't need this section, strip it from the
3166 output file. This is mostly to handle .rela.bss and
3167 .rela.plt. We must create both sections in
3168 create_dynamic_sections, because they must be created
3169 before the linker maps input sections to output
3170 sections. The linker does that before
3171 adjust_dynamic_symbol is called, and it is that
3172 function which decides whether anything needs to go
3173 into these sections. */
3175 s
->flags
|= SEC_EXCLUDE
;
3179 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3182 /* Allocate memory for the section contents. We use bfd_zalloc
3183 here in case unused entries are not reclaimed before the
3184 section's contents are written out. This should not happen,
3185 but this way if it does, we get a R_X86_64_NONE reloc instead
3187 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3188 if (s
->contents
== NULL
)
3192 if (htab
->plt_eh_frame
!= NULL
3193 && htab
->plt_eh_frame
->contents
!= NULL
)
3195 const struct elf_x86_64_backend_data
*arch_data
3196 = get_elf_x86_64_arch_data (bed
);
3198 memcpy (htab
->plt_eh_frame
->contents
,
3199 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3200 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3201 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3204 if (htab
->elf
.dynamic_sections_created
)
3206 /* Add some entries to the .dynamic section. We fill in the
3207 values later, in elf_x86_64_finish_dynamic_sections, but we
3208 must add the entries now so that we get the correct size for
3209 the .dynamic section. The DT_DEBUG entry is filled in by the
3210 dynamic linker and used by the debugger. */
3211 #define add_dynamic_entry(TAG, VAL) \
3212 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3214 if (info
->executable
)
3216 if (!add_dynamic_entry (DT_DEBUG
, 0))
3220 if (htab
->elf
.splt
->size
!= 0)
3222 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3223 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3224 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3225 || !add_dynamic_entry (DT_JMPREL
, 0))
3228 if (htab
->tlsdesc_plt
3229 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3230 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3236 if (!add_dynamic_entry (DT_RELA
, 0)
3237 || !add_dynamic_entry (DT_RELASZ
, 0)
3238 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3241 /* If any dynamic relocs apply to a read-only section,
3242 then we need a DT_TEXTREL entry. */
3243 if ((info
->flags
& DF_TEXTREL
) == 0)
3244 elf_link_hash_traverse (&htab
->elf
,
3245 elf_x86_64_readonly_dynrelocs
,
3248 if ((info
->flags
& DF_TEXTREL
) != 0)
3250 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3255 #undef add_dynamic_entry
3261 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3262 struct bfd_link_info
*info
)
3264 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3268 struct elf_link_hash_entry
*tlsbase
;
3270 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3271 "_TLS_MODULE_BASE_",
3272 FALSE
, FALSE
, FALSE
);
3274 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3276 struct elf_x86_64_link_hash_table
*htab
;
3277 struct bfd_link_hash_entry
*bh
= NULL
;
3278 const struct elf_backend_data
*bed
3279 = get_elf_backend_data (output_bfd
);
3281 htab
= elf_x86_64_hash_table (info
);
3285 if (!(_bfd_generic_link_add_one_symbol
3286 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3287 tls_sec
, 0, NULL
, FALSE
,
3288 bed
->collect
, &bh
)))
3291 htab
->tls_module_base
= bh
;
3293 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3294 tlsbase
->def_regular
= 1;
3295 tlsbase
->other
= STV_HIDDEN
;
3296 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3303 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3304 executables. Rather than setting it to the beginning of the TLS
3305 section, we have to set it to the end. This function may be called
3306 multiple times, it is idempotent. */
3309 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3311 struct elf_x86_64_link_hash_table
*htab
;
3312 struct bfd_link_hash_entry
*base
;
3314 if (!info
->executable
)
3317 htab
= elf_x86_64_hash_table (info
);
3321 base
= htab
->tls_module_base
;
3325 base
->u
.def
.value
= htab
->elf
.tls_size
;
3328 /* Return the base VMA address which should be subtracted from real addresses
3329 when resolving @dtpoff relocation.
3330 This is PT_TLS segment p_vaddr. */
3333 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3335 /* If tls_sec is NULL, we should have signalled an error already. */
3336 if (elf_hash_table (info
)->tls_sec
== NULL
)
3338 return elf_hash_table (info
)->tls_sec
->vma
;
3341 /* Return the relocation value for @tpoff relocation
3342 if STT_TLS virtual address is ADDRESS. */
3345 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3347 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3348 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3349 bfd_vma static_tls_size
;
3351 /* If tls_segment is NULL, we should have signalled an error already. */
3352 if (htab
->tls_sec
== NULL
)
3355 /* Consider special static TLS alignment requirements. */
3356 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3357 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3360 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3364 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3366 /* Opcode Instruction
3369 0x0f 0x8x conditional jump */
3371 && (contents
[offset
- 1] == 0xe8
3372 || contents
[offset
- 1] == 0xe9))
3374 && contents
[offset
- 2] == 0x0f
3375 && (contents
[offset
- 1] & 0xf0) == 0x80));
3378 /* Relocate an x86_64 ELF section. */
3381 elf_x86_64_relocate_section (bfd
*output_bfd
,
3382 struct bfd_link_info
*info
,
3384 asection
*input_section
,
3386 Elf_Internal_Rela
*relocs
,
3387 Elf_Internal_Sym
*local_syms
,
3388 asection
**local_sections
)
3390 struct elf_x86_64_link_hash_table
*htab
;
3391 Elf_Internal_Shdr
*symtab_hdr
;
3392 struct elf_link_hash_entry
**sym_hashes
;
3393 bfd_vma
*local_got_offsets
;
3394 bfd_vma
*local_tlsdesc_gotents
;
3395 Elf_Internal_Rela
*rel
;
3396 Elf_Internal_Rela
*relend
;
3397 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3399 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3401 htab
= elf_x86_64_hash_table (info
);
3404 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3405 sym_hashes
= elf_sym_hashes (input_bfd
);
3406 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3407 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3409 elf_x86_64_set_tls_module_base (info
);
3412 relend
= relocs
+ input_section
->reloc_count
;
3413 for (; rel
< relend
; rel
++)
3415 unsigned int r_type
;
3416 reloc_howto_type
*howto
;
3417 unsigned long r_symndx
;
3418 struct elf_link_hash_entry
*h
;
3419 struct elf_x86_64_link_hash_entry
*eh
;
3420 Elf_Internal_Sym
*sym
;
3422 bfd_vma off
, offplt
, plt_offset
;
3424 bfd_boolean unresolved_reloc
;
3425 bfd_reloc_status_type r
;
3427 asection
*base_got
, *resolved_plt
;
3430 r_type
= ELF32_R_TYPE (rel
->r_info
);
3431 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3432 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3435 if (r_type
>= (int) R_X86_64_standard
)
3437 (*_bfd_error_handler
)
3438 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3439 input_bfd
, input_section
, r_type
);
3440 bfd_set_error (bfd_error_bad_value
);
3444 if (r_type
!= (int) R_X86_64_32
3445 || ABI_64_P (output_bfd
))
3446 howto
= x86_64_elf_howto_table
+ r_type
;
3448 howto
= (x86_64_elf_howto_table
3449 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3450 r_symndx
= htab
->r_sym (rel
->r_info
);
3454 unresolved_reloc
= FALSE
;
3455 if (r_symndx
< symtab_hdr
->sh_info
)
3457 sym
= local_syms
+ r_symndx
;
3458 sec
= local_sections
[r_symndx
];
3460 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3462 st_size
= sym
->st_size
;
3464 /* Relocate against local STT_GNU_IFUNC symbol. */
3465 if (!info
->relocatable
3466 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3468 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3473 /* Set STT_GNU_IFUNC symbol value. */
3474 h
->root
.u
.def
.value
= sym
->st_value
;
3475 h
->root
.u
.def
.section
= sec
;
3480 bfd_boolean warned ATTRIBUTE_UNUSED
;
3481 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3483 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3484 r_symndx
, symtab_hdr
, sym_hashes
,
3486 unresolved_reloc
, warned
, ignored
);
3490 if (sec
!= NULL
&& discarded_section (sec
))
3491 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3492 rel
, 1, relend
, howto
, 0, contents
);
3494 if (info
->relocatable
)
3497 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3499 if (r_type
== R_X86_64_64
)
3501 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3502 zero-extend it to 64bit if addend is zero. */
3503 r_type
= R_X86_64_32
;
3504 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3506 else if (r_type
== R_X86_64_SIZE64
)
3508 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3509 zero-extend it to 64bit if addend is zero. */
3510 r_type
= R_X86_64_SIZE32
;
3511 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3515 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3517 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3518 it here if it is defined in a non-shared object. */
3520 && h
->type
== STT_GNU_IFUNC
3526 if ((input_section
->flags
& SEC_ALLOC
) == 0
3527 || h
->plt
.offset
== (bfd_vma
) -1)
3530 /* STT_GNU_IFUNC symbol must go through PLT. */
3531 if (htab
->elf
.splt
!= NULL
)
3533 if (htab
->plt_bnd
!= NULL
)
3535 resolved_plt
= htab
->plt_bnd
;
3536 plt_offset
= eh
->plt_bnd
.offset
;
3540 resolved_plt
= htab
->elf
.splt
;
3541 plt_offset
= h
->plt
.offset
;
3546 resolved_plt
= htab
->elf
.iplt
;
3547 plt_offset
= h
->plt
.offset
;
3550 relocation
= (resolved_plt
->output_section
->vma
3551 + resolved_plt
->output_offset
+ plt_offset
);
3556 if (h
->root
.root
.string
)
3557 name
= h
->root
.root
.string
;
3559 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3561 (*_bfd_error_handler
)
3562 (_("%B: relocation %s against STT_GNU_IFUNC "
3563 "symbol `%s' isn't handled by %s"), input_bfd
,
3564 x86_64_elf_howto_table
[r_type
].name
,
3565 name
, __FUNCTION__
);
3566 bfd_set_error (bfd_error_bad_value
);
3575 if (ABI_64_P (output_bfd
))
3579 if (rel
->r_addend
!= 0)
3581 if (h
->root
.root
.string
)
3582 name
= h
->root
.root
.string
;
3584 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3586 (*_bfd_error_handler
)
3587 (_("%B: relocation %s against STT_GNU_IFUNC "
3588 "symbol `%s' has non-zero addend: %d"),
3589 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3590 name
, rel
->r_addend
);
3591 bfd_set_error (bfd_error_bad_value
);
3595 /* Generate dynamic relcoation only when there is a
3596 non-GOT reference in a shared object. */
3597 if (info
->shared
&& h
->non_got_ref
)
3599 Elf_Internal_Rela outrel
;
3602 /* Need a dynamic relocation to get the real function
3604 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3608 if (outrel
.r_offset
== (bfd_vma
) -1
3609 || outrel
.r_offset
== (bfd_vma
) -2)
3612 outrel
.r_offset
+= (input_section
->output_section
->vma
3613 + input_section
->output_offset
);
3615 if (h
->dynindx
== -1
3617 || info
->executable
)
3619 /* This symbol is resolved locally. */
3620 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3621 outrel
.r_addend
= (h
->root
.u
.def
.value
3622 + h
->root
.u
.def
.section
->output_section
->vma
3623 + h
->root
.u
.def
.section
->output_offset
);
3627 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3628 outrel
.r_addend
= 0;
3631 sreloc
= htab
->elf
.irelifunc
;
3632 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3634 /* If this reloc is against an external symbol, we
3635 do not want to fiddle with the addend. Otherwise,
3636 we need to include the symbol value so that it
3637 becomes an addend for the dynamic reloc. For an
3638 internal symbol, we have updated addend. */
3643 case R_X86_64_PC32_BND
:
3645 case R_X86_64_PLT32
:
3646 case R_X86_64_PLT32_BND
:
3649 case R_X86_64_GOTPCREL
:
3650 case R_X86_64_GOTPCREL64
:
3651 base_got
= htab
->elf
.sgot
;
3652 off
= h
->got
.offset
;
3654 if (base_got
== NULL
)
3657 if (off
== (bfd_vma
) -1)
3659 /* We can't use h->got.offset here to save state, or
3660 even just remember the offset, as finish_dynamic_symbol
3661 would use that as offset into .got. */
3663 if (htab
->elf
.splt
!= NULL
)
3665 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3666 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3667 base_got
= htab
->elf
.sgotplt
;
3671 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3672 off
= plt_index
* GOT_ENTRY_SIZE
;
3673 base_got
= htab
->elf
.igotplt
;
3676 if (h
->dynindx
== -1
3680 /* This references the local defitionion. We must
3681 initialize this entry in the global offset table.
3682 Since the offset must always be a multiple of 8,
3683 we use the least significant bit to record
3684 whether we have initialized it already.
3686 When doing a dynamic link, we create a .rela.got
3687 relocation entry to initialize the value. This
3688 is done in the finish_dynamic_symbol routine. */
3693 bfd_put_64 (output_bfd
, relocation
,
3694 base_got
->contents
+ off
);
3695 /* Note that this is harmless for the GOTPLT64
3696 case, as -1 | 1 still is -1. */
3702 relocation
= (base_got
->output_section
->vma
3703 + base_got
->output_offset
+ off
);
3709 /* When generating a shared object, the relocations handled here are
3710 copied into the output file to be resolved at run time. */
3713 case R_X86_64_GOT32
:
3714 case R_X86_64_GOT64
:
3715 /* Relocation is to the entry for this symbol in the global
3717 case R_X86_64_GOTPCREL
:
3718 case R_X86_64_GOTPCREL64
:
3719 /* Use global offset table entry as symbol value. */
3720 case R_X86_64_GOTPLT64
:
3721 /* This is the same as GOT64 for relocation purposes, but
3722 indicates the existence of a PLT entry. The difficulty is,
3723 that we must calculate the GOT slot offset from the PLT
3724 offset, if this symbol got a PLT entry (it was global).
3725 Additionally if it's computed from the PLT entry, then that
3726 GOT offset is relative to .got.plt, not to .got. */
3727 base_got
= htab
->elf
.sgot
;
3729 if (htab
->elf
.sgot
== NULL
)
3736 off
= h
->got
.offset
;
3738 && h
->plt
.offset
!= (bfd_vma
)-1
3739 && off
== (bfd_vma
)-1)
3741 /* We can't use h->got.offset here to save
3742 state, or even just remember the offset, as
3743 finish_dynamic_symbol would use that as offset into
3745 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3746 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3747 base_got
= htab
->elf
.sgotplt
;
3750 dyn
= htab
->elf
.dynamic_sections_created
;
3752 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3754 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3755 || (ELF_ST_VISIBILITY (h
->other
)
3756 && h
->root
.type
== bfd_link_hash_undefweak
))
3758 /* This is actually a static link, or it is a -Bsymbolic
3759 link and the symbol is defined locally, or the symbol
3760 was forced to be local because of a version file. We
3761 must initialize this entry in the global offset table.
3762 Since the offset must always be a multiple of 8, we
3763 use the least significant bit to record whether we
3764 have initialized it already.
3766 When doing a dynamic link, we create a .rela.got
3767 relocation entry to initialize the value. This is
3768 done in the finish_dynamic_symbol routine. */
3773 bfd_put_64 (output_bfd
, relocation
,
3774 base_got
->contents
+ off
);
3775 /* Note that this is harmless for the GOTPLT64 case,
3776 as -1 | 1 still is -1. */
3781 unresolved_reloc
= FALSE
;
3785 if (local_got_offsets
== NULL
)
3788 off
= local_got_offsets
[r_symndx
];
3790 /* The offset must always be a multiple of 8. We use
3791 the least significant bit to record whether we have
3792 already generated the necessary reloc. */
3797 bfd_put_64 (output_bfd
, relocation
,
3798 base_got
->contents
+ off
);
3803 Elf_Internal_Rela outrel
;
3805 /* We need to generate a R_X86_64_RELATIVE reloc
3806 for the dynamic linker. */
3807 s
= htab
->elf
.srelgot
;
3811 outrel
.r_offset
= (base_got
->output_section
->vma
3812 + base_got
->output_offset
3814 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3815 outrel
.r_addend
= relocation
;
3816 elf_append_rela (output_bfd
, s
, &outrel
);
3819 local_got_offsets
[r_symndx
] |= 1;
3823 if (off
>= (bfd_vma
) -2)
3826 relocation
= base_got
->output_section
->vma
3827 + base_got
->output_offset
+ off
;
3828 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3829 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3830 - htab
->elf
.sgotplt
->output_offset
;
3834 case R_X86_64_GOTOFF64
:
3835 /* Relocation is relative to the start of the global offset
3838 /* Check to make sure it isn't a protected function symbol
3839 for shared library since it may not be local when used
3840 as function address. */
3841 if (!info
->executable
3843 && !SYMBOLIC_BIND (info
, h
)
3845 && h
->type
== STT_FUNC
3846 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3848 (*_bfd_error_handler
)
3849 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3850 input_bfd
, h
->root
.root
.string
);
3851 bfd_set_error (bfd_error_bad_value
);
3855 /* Note that sgot is not involved in this
3856 calculation. We always want the start of .got.plt. If we
3857 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3858 permitted by the ABI, we might have to change this
3860 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3861 + htab
->elf
.sgotplt
->output_offset
;
3864 case R_X86_64_GOTPC32
:
3865 case R_X86_64_GOTPC64
:
3866 /* Use global offset table as symbol value. */
3867 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3868 + htab
->elf
.sgotplt
->output_offset
;
3869 unresolved_reloc
= FALSE
;
3872 case R_X86_64_PLTOFF64
:
3873 /* Relocation is PLT entry relative to GOT. For local
3874 symbols it's the symbol itself relative to GOT. */
3876 /* See PLT32 handling. */
3877 && h
->plt
.offset
!= (bfd_vma
) -1
3878 && htab
->elf
.splt
!= NULL
)
3880 if (htab
->plt_bnd
!= NULL
)
3882 resolved_plt
= htab
->plt_bnd
;
3883 plt_offset
= eh
->plt_bnd
.offset
;
3887 resolved_plt
= htab
->elf
.splt
;
3888 plt_offset
= h
->plt
.offset
;
3891 relocation
= (resolved_plt
->output_section
->vma
3892 + resolved_plt
->output_offset
3894 unresolved_reloc
= FALSE
;
3897 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3898 + htab
->elf
.sgotplt
->output_offset
;
3901 case R_X86_64_PLT32
:
3902 case R_X86_64_PLT32_BND
:
3903 /* Relocation is to the entry for this symbol in the
3904 procedure linkage table. */
3906 /* Resolve a PLT32 reloc against a local symbol directly,
3907 without using the procedure linkage table. */
3911 if (h
->plt
.offset
== (bfd_vma
) -1
3912 || htab
->elf
.splt
== NULL
)
3914 /* We didn't make a PLT entry for this symbol. This
3915 happens when statically linking PIC code, or when
3916 using -Bsymbolic. */
3920 if (htab
->plt_bnd
!= NULL
)
3922 resolved_plt
= htab
->plt_bnd
;
3923 plt_offset
= eh
->plt_bnd
.offset
;
3927 resolved_plt
= htab
->elf
.splt
;
3928 plt_offset
= h
->plt
.offset
;
3931 relocation
= (resolved_plt
->output_section
->vma
3932 + resolved_plt
->output_offset
3934 unresolved_reloc
= FALSE
;
3937 case R_X86_64_SIZE32
:
3938 case R_X86_64_SIZE64
:
3939 /* Set to symbol size. */
3940 relocation
= st_size
;
3946 case R_X86_64_PC32_BND
:
3948 && (input_section
->flags
& SEC_ALLOC
) != 0
3949 && (input_section
->flags
& SEC_READONLY
) != 0
3952 bfd_boolean fail
= FALSE
;
3954 = ((r_type
== R_X86_64_PC32
3955 || r_type
== R_X86_64_PC32_BND
)
3956 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3958 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3960 /* Symbol is referenced locally. Make sure it is
3961 defined locally or for a branch. */
3962 fail
= !h
->def_regular
&& !branch
;
3966 /* Symbol isn't referenced locally. We only allow
3967 branch to symbol with non-default visibility. */
3969 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3976 const char *pic
= "";
3978 switch (ELF_ST_VISIBILITY (h
->other
))
3981 v
= _("hidden symbol");
3984 v
= _("internal symbol");
3987 v
= _("protected symbol");
3991 pic
= _("; recompile with -fPIC");
3996 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3998 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4000 (*_bfd_error_handler
) (fmt
, input_bfd
,
4001 x86_64_elf_howto_table
[r_type
].name
,
4002 v
, h
->root
.root
.string
, pic
);
4003 bfd_set_error (bfd_error_bad_value
);
4014 /* FIXME: The ABI says the linker should make sure the value is
4015 the same when it's zeroextended to 64 bit. */
4018 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4023 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4024 || h
->root
.type
!= bfd_link_hash_undefweak
)
4025 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4026 && r_type
!= R_X86_64_SIZE32
4027 && r_type
!= R_X86_64_SIZE64
)
4028 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4029 || (ELIMINATE_COPY_RELOCS
4036 || h
->root
.type
== bfd_link_hash_undefweak
4037 || h
->root
.type
== bfd_link_hash_undefined
)))
4039 Elf_Internal_Rela outrel
;
4040 bfd_boolean skip
, relocate
;
4043 /* When generating a shared object, these relocations
4044 are copied into the output file to be resolved at run
4050 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4052 if (outrel
.r_offset
== (bfd_vma
) -1)
4054 else if (outrel
.r_offset
== (bfd_vma
) -2)
4055 skip
= TRUE
, relocate
= TRUE
;
4057 outrel
.r_offset
+= (input_section
->output_section
->vma
4058 + input_section
->output_offset
);
4061 memset (&outrel
, 0, sizeof outrel
);
4063 /* h->dynindx may be -1 if this symbol was marked to
4067 && (IS_X86_64_PCREL_TYPE (r_type
)
4069 || ! SYMBOLIC_BIND (info
, h
)
4070 || ! h
->def_regular
))
4072 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4073 outrel
.r_addend
= rel
->r_addend
;
4077 /* This symbol is local, or marked to become local. */
4078 if (r_type
== htab
->pointer_r_type
)
4081 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4082 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4084 else if (r_type
== R_X86_64_64
4085 && !ABI_64_P (output_bfd
))
4088 outrel
.r_info
= htab
->r_info (0,
4089 R_X86_64_RELATIVE64
);
4090 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4091 /* Check addend overflow. */
4092 if ((outrel
.r_addend
& 0x80000000)
4093 != (rel
->r_addend
& 0x80000000))
4096 int addend
= rel
->r_addend
;
4097 if (h
&& h
->root
.root
.string
)
4098 name
= h
->root
.root
.string
;
4100 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4103 (*_bfd_error_handler
)
4104 (_("%B: addend -0x%x in relocation %s against "
4105 "symbol `%s' at 0x%lx in section `%A' is "
4107 input_bfd
, input_section
, addend
,
4108 x86_64_elf_howto_table
[r_type
].name
,
4109 name
, (unsigned long) rel
->r_offset
);
4111 (*_bfd_error_handler
)
4112 (_("%B: addend 0x%x in relocation %s against "
4113 "symbol `%s' at 0x%lx in section `%A' is "
4115 input_bfd
, input_section
, addend
,
4116 x86_64_elf_howto_table
[r_type
].name
,
4117 name
, (unsigned long) rel
->r_offset
);
4118 bfd_set_error (bfd_error_bad_value
);
4126 if (bfd_is_abs_section (sec
))
4128 else if (sec
== NULL
|| sec
->owner
== NULL
)
4130 bfd_set_error (bfd_error_bad_value
);
4137 /* We are turning this relocation into one
4138 against a section symbol. It would be
4139 proper to subtract the symbol's value,
4140 osec->vma, from the emitted reloc addend,
4141 but ld.so expects buggy relocs. */
4142 osec
= sec
->output_section
;
4143 sindx
= elf_section_data (osec
)->dynindx
;
4146 asection
*oi
= htab
->elf
.text_index_section
;
4147 sindx
= elf_section_data (oi
)->dynindx
;
4149 BFD_ASSERT (sindx
!= 0);
4152 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4153 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4157 sreloc
= elf_section_data (input_section
)->sreloc
;
4159 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4161 r
= bfd_reloc_notsupported
;
4162 goto check_relocation_error
;
4165 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4167 /* If this reloc is against an external symbol, we do
4168 not want to fiddle with the addend. Otherwise, we
4169 need to include the symbol value so that it becomes
4170 an addend for the dynamic reloc. */
4177 case R_X86_64_TLSGD
:
4178 case R_X86_64_GOTPC32_TLSDESC
:
4179 case R_X86_64_TLSDESC_CALL
:
4180 case R_X86_64_GOTTPOFF
:
4181 tls_type
= GOT_UNKNOWN
;
4182 if (h
== NULL
&& local_got_offsets
)
4183 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4185 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4187 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4188 input_section
, contents
,
4189 symtab_hdr
, sym_hashes
,
4190 &r_type
, tls_type
, rel
,
4191 relend
, h
, r_symndx
))
4194 if (r_type
== R_X86_64_TPOFF32
)
4196 bfd_vma roff
= rel
->r_offset
;
4198 BFD_ASSERT (! unresolved_reloc
);
4200 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4202 /* GD->LE transition. For 64bit, change
4203 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4204 .word 0x6666; rex64; call __tls_get_addr
4207 leaq foo@tpoff(%rax), %rax
4209 leaq foo@tlsgd(%rip), %rdi
4210 .word 0x6666; rex64; call __tls_get_addr
4213 leaq foo@tpoff(%rax), %rax
4214 For largepic, change:
4215 leaq foo@tlsgd(%rip), %rdi
4216 movabsq $__tls_get_addr@pltoff, %rax
4221 leaq foo@tpoff(%rax), %rax
4222 nopw 0x0(%rax,%rax,1) */
4224 if (ABI_64_P (output_bfd
)
4225 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4227 memcpy (contents
+ roff
- 3,
4228 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4229 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4232 else if (ABI_64_P (output_bfd
))
4233 memcpy (contents
+ roff
- 4,
4234 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4237 memcpy (contents
+ roff
- 3,
4238 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4240 bfd_put_32 (output_bfd
,
4241 elf_x86_64_tpoff (info
, relocation
),
4242 contents
+ roff
+ 8 + largepic
);
4243 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4247 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4249 /* GDesc -> LE transition.
4250 It's originally something like:
4251 leaq x@tlsdesc(%rip), %rax
4254 movl $x@tpoff, %rax. */
4256 unsigned int val
, type
;
4258 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4259 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4260 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4261 contents
+ roff
- 3);
4262 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4263 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4264 contents
+ roff
- 1);
4265 bfd_put_32 (output_bfd
,
4266 elf_x86_64_tpoff (info
, relocation
),
4270 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4272 /* GDesc -> LE transition.
4277 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4278 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4281 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4283 /* IE->LE transition:
4284 Originally it can be one of:
4285 movq foo@gottpoff(%rip), %reg
4286 addq foo@gottpoff(%rip), %reg
4289 leaq foo(%reg), %reg
4292 unsigned int val
, type
, reg
;
4294 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4295 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4296 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4302 bfd_put_8 (output_bfd
, 0x49,
4303 contents
+ roff
- 3);
4304 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4305 bfd_put_8 (output_bfd
, 0x41,
4306 contents
+ roff
- 3);
4307 bfd_put_8 (output_bfd
, 0xc7,
4308 contents
+ roff
- 2);
4309 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4310 contents
+ roff
- 1);
4314 /* addq -> addq - addressing with %rsp/%r12 is
4317 bfd_put_8 (output_bfd
, 0x49,
4318 contents
+ roff
- 3);
4319 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4320 bfd_put_8 (output_bfd
, 0x41,
4321 contents
+ roff
- 3);
4322 bfd_put_8 (output_bfd
, 0x81,
4323 contents
+ roff
- 2);
4324 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4325 contents
+ roff
- 1);
4331 bfd_put_8 (output_bfd
, 0x4d,
4332 contents
+ roff
- 3);
4333 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4334 bfd_put_8 (output_bfd
, 0x45,
4335 contents
+ roff
- 3);
4336 bfd_put_8 (output_bfd
, 0x8d,
4337 contents
+ roff
- 2);
4338 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4339 contents
+ roff
- 1);
4341 bfd_put_32 (output_bfd
,
4342 elf_x86_64_tpoff (info
, relocation
),
4350 if (htab
->elf
.sgot
== NULL
)
4355 off
= h
->got
.offset
;
4356 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4360 if (local_got_offsets
== NULL
)
4363 off
= local_got_offsets
[r_symndx
];
4364 offplt
= local_tlsdesc_gotents
[r_symndx
];
4371 Elf_Internal_Rela outrel
;
4375 if (htab
->elf
.srelgot
== NULL
)
4378 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4380 if (GOT_TLS_GDESC_P (tls_type
))
4382 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4383 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4384 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4385 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4386 + htab
->elf
.sgotplt
->output_offset
4388 + htab
->sgotplt_jump_table_size
);
4389 sreloc
= htab
->elf
.srelplt
;
4391 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4393 outrel
.r_addend
= 0;
4394 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4397 sreloc
= htab
->elf
.srelgot
;
4399 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4400 + htab
->elf
.sgot
->output_offset
+ off
);
4402 if (GOT_TLS_GD_P (tls_type
))
4403 dr_type
= R_X86_64_DTPMOD64
;
4404 else if (GOT_TLS_GDESC_P (tls_type
))
4407 dr_type
= R_X86_64_TPOFF64
;
4409 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4410 outrel
.r_addend
= 0;
4411 if ((dr_type
== R_X86_64_TPOFF64
4412 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4413 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4414 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4416 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4418 if (GOT_TLS_GD_P (tls_type
))
4422 BFD_ASSERT (! unresolved_reloc
);
4423 bfd_put_64 (output_bfd
,
4424 relocation
- elf_x86_64_dtpoff_base (info
),
4425 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4429 bfd_put_64 (output_bfd
, 0,
4430 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4431 outrel
.r_info
= htab
->r_info (indx
,
4433 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4434 elf_append_rela (output_bfd
, sreloc
,
4443 local_got_offsets
[r_symndx
] |= 1;
4446 if (off
>= (bfd_vma
) -2
4447 && ! GOT_TLS_GDESC_P (tls_type
))
4449 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4451 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4452 || r_type
== R_X86_64_TLSDESC_CALL
)
4453 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4454 + htab
->elf
.sgotplt
->output_offset
4455 + offplt
+ htab
->sgotplt_jump_table_size
;
4457 relocation
= htab
->elf
.sgot
->output_section
->vma
4458 + htab
->elf
.sgot
->output_offset
+ off
;
4459 unresolved_reloc
= FALSE
;
4463 bfd_vma roff
= rel
->r_offset
;
4465 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4467 /* GD->IE transition. For 64bit, change
4468 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4469 .word 0x6666; rex64; call __tls_get_addr@plt
4472 addq foo@gottpoff(%rip), %rax
4474 leaq foo@tlsgd(%rip), %rdi
4475 .word 0x6666; rex64; call __tls_get_addr@plt
4478 addq foo@gottpoff(%rip), %rax
4479 For largepic, change:
4480 leaq foo@tlsgd(%rip), %rdi
4481 movabsq $__tls_get_addr@pltoff, %rax
4486 addq foo@gottpoff(%rax), %rax
4487 nopw 0x0(%rax,%rax,1) */
4489 if (ABI_64_P (output_bfd
)
4490 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4492 memcpy (contents
+ roff
- 3,
4493 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4494 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4497 else if (ABI_64_P (output_bfd
))
4498 memcpy (contents
+ roff
- 4,
4499 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4502 memcpy (contents
+ roff
- 3,
4503 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4506 relocation
= (htab
->elf
.sgot
->output_section
->vma
4507 + htab
->elf
.sgot
->output_offset
+ off
4510 - input_section
->output_section
->vma
4511 - input_section
->output_offset
4513 bfd_put_32 (output_bfd
, relocation
,
4514 contents
+ roff
+ 8 + largepic
);
4515 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4519 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4521 /* GDesc -> IE transition.
4522 It's originally something like:
4523 leaq x@tlsdesc(%rip), %rax
4526 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4528 /* Now modify the instruction as appropriate. To
4529 turn a leaq into a movq in the form we use it, it
4530 suffices to change the second byte from 0x8d to
4532 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4534 bfd_put_32 (output_bfd
,
4535 htab
->elf
.sgot
->output_section
->vma
4536 + htab
->elf
.sgot
->output_offset
+ off
4538 - input_section
->output_section
->vma
4539 - input_section
->output_offset
4544 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4546 /* GDesc -> IE transition.
4553 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4554 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4562 case R_X86_64_TLSLD
:
4563 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4564 input_section
, contents
,
4565 symtab_hdr
, sym_hashes
,
4566 &r_type
, GOT_UNKNOWN
,
4567 rel
, relend
, h
, r_symndx
))
4570 if (r_type
!= R_X86_64_TLSLD
)
4572 /* LD->LE transition:
4573 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4574 For 64bit, we change it into:
4575 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4576 For 32bit, we change it into:
4577 nopl 0x0(%rax); movl %fs:0, %eax.
4578 For largepic, change:
4579 leaq foo@tlsgd(%rip), %rdi
4580 movabsq $__tls_get_addr@pltoff, %rax
4584 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4587 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4588 if (ABI_64_P (output_bfd
)
4589 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4590 memcpy (contents
+ rel
->r_offset
- 3,
4591 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4592 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4593 else if (ABI_64_P (output_bfd
))
4594 memcpy (contents
+ rel
->r_offset
- 3,
4595 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4597 memcpy (contents
+ rel
->r_offset
- 3,
4598 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4599 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4604 if (htab
->elf
.sgot
== NULL
)
4607 off
= htab
->tls_ld_got
.offset
;
4612 Elf_Internal_Rela outrel
;
4614 if (htab
->elf
.srelgot
== NULL
)
4617 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4618 + htab
->elf
.sgot
->output_offset
+ off
);
4620 bfd_put_64 (output_bfd
, 0,
4621 htab
->elf
.sgot
->contents
+ off
);
4622 bfd_put_64 (output_bfd
, 0,
4623 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4624 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4625 outrel
.r_addend
= 0;
4626 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4628 htab
->tls_ld_got
.offset
|= 1;
4630 relocation
= htab
->elf
.sgot
->output_section
->vma
4631 + htab
->elf
.sgot
->output_offset
+ off
;
4632 unresolved_reloc
= FALSE
;
4635 case R_X86_64_DTPOFF32
:
4636 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4637 relocation
-= elf_x86_64_dtpoff_base (info
);
4639 relocation
= elf_x86_64_tpoff (info
, relocation
);
4642 case R_X86_64_TPOFF32
:
4643 case R_X86_64_TPOFF64
:
4644 BFD_ASSERT (info
->executable
);
4645 relocation
= elf_x86_64_tpoff (info
, relocation
);
4648 case R_X86_64_DTPOFF64
:
4649 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4650 relocation
-= elf_x86_64_dtpoff_base (info
);
4657 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4658 because such sections are not SEC_ALLOC and thus ld.so will
4659 not process them. */
4660 if (unresolved_reloc
4661 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4663 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4664 rel
->r_offset
) != (bfd_vma
) -1)
4666 (*_bfd_error_handler
)
4667 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4670 (long) rel
->r_offset
,
4672 h
->root
.root
.string
);
4677 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4678 contents
, rel
->r_offset
,
4679 relocation
, rel
->r_addend
);
4681 check_relocation_error
:
4682 if (r
!= bfd_reloc_ok
)
4687 name
= h
->root
.root
.string
;
4690 name
= bfd_elf_string_from_elf_section (input_bfd
,
4691 symtab_hdr
->sh_link
,
4696 name
= bfd_section_name (input_bfd
, sec
);
4699 if (r
== bfd_reloc_overflow
)
4701 if (! ((*info
->callbacks
->reloc_overflow
)
4702 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4703 (bfd_vma
) 0, input_bfd
, input_section
,
4709 (*_bfd_error_handler
)
4710 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4711 input_bfd
, input_section
,
4712 (long) rel
->r_offset
, name
, (int) r
);
4721 /* Finish up dynamic symbol handling. We set the contents of various
4722 dynamic sections here. */
4725 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4726 struct bfd_link_info
*info
,
4727 struct elf_link_hash_entry
*h
,
4728 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4730 struct elf_x86_64_link_hash_table
*htab
;
4731 const struct elf_x86_64_backend_data
*abed
;
4732 bfd_boolean use_plt_bnd
;
4734 htab
= elf_x86_64_hash_table (info
);
4738 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4739 section only if there is .plt section. */
4740 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
4742 ? &elf_x86_64_bnd_arch_bed
4743 : get_elf_x86_64_backend_data (output_bfd
));
4745 if (h
->plt
.offset
!= (bfd_vma
) -1)
4748 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
4749 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
4750 Elf_Internal_Rela rela
;
4752 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4753 const struct elf_backend_data
*bed
;
4755 /* When building a static executable, use .iplt, .igot.plt and
4756 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4757 if (htab
->elf
.splt
!= NULL
)
4759 plt
= htab
->elf
.splt
;
4760 gotplt
= htab
->elf
.sgotplt
;
4761 relplt
= htab
->elf
.srelplt
;
4765 plt
= htab
->elf
.iplt
;
4766 gotplt
= htab
->elf
.igotplt
;
4767 relplt
= htab
->elf
.irelplt
;
4770 /* This symbol has an entry in the procedure linkage table. Set
4772 if ((h
->dynindx
== -1
4773 && !((h
->forced_local
|| info
->executable
)
4775 && h
->type
== STT_GNU_IFUNC
))
4781 /* Get the index in the procedure linkage table which
4782 corresponds to this symbol. This is the index of this symbol
4783 in all the symbols for which we are making plt entries. The
4784 first entry in the procedure linkage table is reserved.
4786 Get the offset into the .got table of the entry that
4787 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4788 bytes. The first three are reserved for the dynamic linker.
4790 For static executables, we don't reserve anything. */
4792 if (plt
== htab
->elf
.splt
)
4794 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4795 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4799 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4800 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4803 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
4804 plt_plt_offset
= abed
->plt_plt_offset
;
4805 plt_got_insn_size
= abed
->plt_got_insn_size
;
4806 plt_got_offset
= abed
->plt_got_offset
;
4809 /* Use the second PLT with BND relocations. */
4810 const bfd_byte
*plt_entry
, *plt2_entry
;
4811 struct elf_x86_64_link_hash_entry
*eh
4812 = (struct elf_x86_64_link_hash_entry
*) h
;
4814 if (eh
->has_bnd_reloc
)
4816 plt_entry
= elf_x86_64_bnd_plt_entry
;
4817 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
4821 plt_entry
= elf_x86_64_legacy_plt_entry
;
4822 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
4824 /* Subtract 1 since there is no BND prefix. */
4825 plt_plt_insn_end
-= 1;
4826 plt_plt_offset
-= 1;
4827 plt_got_insn_size
-= 1;
4828 plt_got_offset
-= 1;
4831 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
4832 == sizeof (elf_x86_64_legacy_plt_entry
));
4834 /* Fill in the entry in the procedure linkage table. */
4835 memcpy (plt
->contents
+ h
->plt
.offset
,
4836 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
4837 /* Fill in the entry in the second PLT. */
4838 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
4839 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
4841 resolved_plt
= htab
->plt_bnd
;
4842 plt_offset
= eh
->plt_bnd
.offset
;
4846 /* Fill in the entry in the procedure linkage table. */
4847 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4848 abed
->plt_entry_size
);
4851 plt_offset
= h
->plt
.offset
;
4854 /* Insert the relocation positions of the plt section. */
4856 /* Put offset the PC-relative instruction referring to the GOT entry,
4857 subtracting the size of that instruction. */
4858 bfd_put_32 (output_bfd
,
4859 (gotplt
->output_section
->vma
4860 + gotplt
->output_offset
4862 - resolved_plt
->output_section
->vma
4863 - resolved_plt
->output_offset
4865 - plt_got_insn_size
),
4866 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
4868 /* Fill in the entry in the global offset table, initially this
4869 points to the second part of the PLT entry. */
4870 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4871 + plt
->output_offset
4872 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4873 gotplt
->contents
+ got_offset
);
4875 /* Fill in the entry in the .rela.plt section. */
4876 rela
.r_offset
= (gotplt
->output_section
->vma
4877 + gotplt
->output_offset
4879 if (h
->dynindx
== -1
4880 || ((info
->executable
4881 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4883 && h
->type
== STT_GNU_IFUNC
))
4885 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4886 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4887 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4888 rela
.r_addend
= (h
->root
.u
.def
.value
4889 + h
->root
.u
.def
.section
->output_section
->vma
4890 + h
->root
.u
.def
.section
->output_offset
);
4891 /* R_X86_64_IRELATIVE comes last. */
4892 plt_index
= htab
->next_irelative_index
--;
4896 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4898 plt_index
= htab
->next_jump_slot_index
++;
4901 /* Don't fill PLT entry for static executables. */
4902 if (plt
== htab
->elf
.splt
)
4904 /* Put relocation index. */
4905 bfd_put_32 (output_bfd
, plt_index
,
4906 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4907 /* Put offset for jmp .PLT0. */
4908 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ plt_plt_insn_end
),
4909 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
4912 bed
= get_elf_backend_data (output_bfd
);
4913 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4914 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4916 if (!h
->def_regular
)
4918 /* Mark the symbol as undefined, rather than as defined in
4919 the .plt section. Leave the value if there were any
4920 relocations where pointer equality matters (this is a clue
4921 for the dynamic linker, to make function pointer
4922 comparisons work between an application and shared
4923 library), otherwise set it to zero. If a function is only
4924 called from a binary, there is no need to slow down
4925 shared libraries because of that. */
4926 sym
->st_shndx
= SHN_UNDEF
;
4927 if (!h
->pointer_equality_needed
)
4932 if (h
->got
.offset
!= (bfd_vma
) -1
4933 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4934 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4936 Elf_Internal_Rela rela
;
4938 /* This symbol has an entry in the global offset table. Set it
4940 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4943 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4944 + htab
->elf
.sgot
->output_offset
4945 + (h
->got
.offset
&~ (bfd_vma
) 1));
4947 /* If this is a static link, or it is a -Bsymbolic link and the
4948 symbol is defined locally or was forced to be local because
4949 of a version file, we just want to emit a RELATIVE reloc.
4950 The entry in the global offset table will already have been
4951 initialized in the relocate_section function. */
4953 && h
->type
== STT_GNU_IFUNC
)
4957 /* Generate R_X86_64_GLOB_DAT. */
4964 if (!h
->pointer_equality_needed
)
4967 /* For non-shared object, we can't use .got.plt, which
4968 contains the real function addres if we need pointer
4969 equality. We load the GOT entry with the PLT entry. */
4970 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4971 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4972 + plt
->output_offset
4974 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4978 else if (info
->shared
4979 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4981 if (!h
->def_regular
)
4983 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4984 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4985 rela
.r_addend
= (h
->root
.u
.def
.value
4986 + h
->root
.u
.def
.section
->output_section
->vma
4987 + h
->root
.u
.def
.section
->output_offset
);
4991 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4993 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4994 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4995 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4999 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5004 Elf_Internal_Rela rela
;
5006 /* This symbol needs a copy reloc. Set it up. */
5008 if (h
->dynindx
== -1
5009 || (h
->root
.type
!= bfd_link_hash_defined
5010 && h
->root
.type
!= bfd_link_hash_defweak
)
5011 || htab
->srelbss
== NULL
)
5014 rela
.r_offset
= (h
->root
.u
.def
.value
5015 + h
->root
.u
.def
.section
->output_section
->vma
5016 + h
->root
.u
.def
.section
->output_offset
);
5017 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5019 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5025 /* Finish up local dynamic symbol handling. We set the contents of
5026 various dynamic sections here. */
5029 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5031 struct elf_link_hash_entry
*h
5032 = (struct elf_link_hash_entry
*) *slot
;
5033 struct bfd_link_info
*info
5034 = (struct bfd_link_info
*) inf
;
5036 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5040 /* Used to decide how to sort relocs in an optimal manner for the
5041 dynamic linker, before writing them out. */
5043 static enum elf_reloc_type_class
5044 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5045 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5046 const Elf_Internal_Rela
*rela
)
5048 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5050 case R_X86_64_RELATIVE
:
5051 case R_X86_64_RELATIVE64
:
5052 return reloc_class_relative
;
5053 case R_X86_64_JUMP_SLOT
:
5054 return reloc_class_plt
;
5056 return reloc_class_copy
;
5058 return reloc_class_normal
;
5062 /* Finish up the dynamic sections. */
5065 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5066 struct bfd_link_info
*info
)
5068 struct elf_x86_64_link_hash_table
*htab
;
5071 const struct elf_x86_64_backend_data
*abed
;
5073 htab
= elf_x86_64_hash_table (info
);
5077 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5078 section only if there is .plt section. */
5079 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5080 ? &elf_x86_64_bnd_arch_bed
5081 : get_elf_x86_64_backend_data (output_bfd
));
5083 dynobj
= htab
->elf
.dynobj
;
5084 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5086 if (htab
->elf
.dynamic_sections_created
)
5088 bfd_byte
*dyncon
, *dynconend
;
5089 const struct elf_backend_data
*bed
;
5090 bfd_size_type sizeof_dyn
;
5092 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5095 bed
= get_elf_backend_data (dynobj
);
5096 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5097 dyncon
= sdyn
->contents
;
5098 dynconend
= sdyn
->contents
+ sdyn
->size
;
5099 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5101 Elf_Internal_Dyn dyn
;
5104 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5112 s
= htab
->elf
.sgotplt
;
5113 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5117 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5121 s
= htab
->elf
.srelplt
->output_section
;
5122 dyn
.d_un
.d_val
= s
->size
;
5126 /* The procedure linkage table relocs (DT_JMPREL) should
5127 not be included in the overall relocs (DT_RELA).
5128 Therefore, we override the DT_RELASZ entry here to
5129 make it not include the JMPREL relocs. Since the
5130 linker script arranges for .rela.plt to follow all
5131 other relocation sections, we don't have to worry
5132 about changing the DT_RELA entry. */
5133 if (htab
->elf
.srelplt
!= NULL
)
5135 s
= htab
->elf
.srelplt
->output_section
;
5136 dyn
.d_un
.d_val
-= s
->size
;
5140 case DT_TLSDESC_PLT
:
5142 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5143 + htab
->tlsdesc_plt
;
5146 case DT_TLSDESC_GOT
:
5148 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5149 + htab
->tlsdesc_got
;
5153 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5156 /* Fill in the special first entry in the procedure linkage table. */
5157 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5159 /* Fill in the first entry in the procedure linkage table. */
5160 memcpy (htab
->elf
.splt
->contents
,
5161 abed
->plt0_entry
, abed
->plt_entry_size
);
5162 /* Add offset for pushq GOT+8(%rip), since the instruction
5163 uses 6 bytes subtract this value. */
5164 bfd_put_32 (output_bfd
,
5165 (htab
->elf
.sgotplt
->output_section
->vma
5166 + htab
->elf
.sgotplt
->output_offset
5168 - htab
->elf
.splt
->output_section
->vma
5169 - htab
->elf
.splt
->output_offset
5171 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5172 /* Add offset for the PC-relative instruction accessing GOT+16,
5173 subtracting the offset to the end of that instruction. */
5174 bfd_put_32 (output_bfd
,
5175 (htab
->elf
.sgotplt
->output_section
->vma
5176 + htab
->elf
.sgotplt
->output_offset
5178 - htab
->elf
.splt
->output_section
->vma
5179 - htab
->elf
.splt
->output_offset
5180 - abed
->plt0_got2_insn_end
),
5181 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5183 elf_section_data (htab
->elf
.splt
->output_section
)
5184 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5186 if (htab
->tlsdesc_plt
)
5188 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5189 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5191 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5192 abed
->plt0_entry
, abed
->plt_entry_size
);
5194 /* Add offset for pushq GOT+8(%rip), since the
5195 instruction uses 6 bytes subtract this value. */
5196 bfd_put_32 (output_bfd
,
5197 (htab
->elf
.sgotplt
->output_section
->vma
5198 + htab
->elf
.sgotplt
->output_offset
5200 - htab
->elf
.splt
->output_section
->vma
5201 - htab
->elf
.splt
->output_offset
5204 htab
->elf
.splt
->contents
5205 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5206 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5207 where TGD stands for htab->tlsdesc_got, subtracting the offset
5208 to the end of that instruction. */
5209 bfd_put_32 (output_bfd
,
5210 (htab
->elf
.sgot
->output_section
->vma
5211 + htab
->elf
.sgot
->output_offset
5213 - htab
->elf
.splt
->output_section
->vma
5214 - htab
->elf
.splt
->output_offset
5216 - abed
->plt0_got2_insn_end
),
5217 htab
->elf
.splt
->contents
5218 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5223 if (htab
->plt_bnd
!= NULL
)
5224 elf_section_data (htab
->plt_bnd
->output_section
)
5225 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5227 if (htab
->elf
.sgotplt
)
5229 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5231 (*_bfd_error_handler
)
5232 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5236 /* Fill in the first three entries in the global offset table. */
5237 if (htab
->elf
.sgotplt
->size
> 0)
5239 /* Set the first entry in the global offset table to the address of
5240 the dynamic section. */
5242 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5244 bfd_put_64 (output_bfd
,
5245 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5246 htab
->elf
.sgotplt
->contents
);
5247 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5248 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5249 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5252 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5256 /* Adjust .eh_frame for .plt section. */
5257 if (htab
->plt_eh_frame
!= NULL
5258 && htab
->plt_eh_frame
->contents
!= NULL
)
5260 if (htab
->elf
.splt
!= NULL
5261 && htab
->elf
.splt
->size
!= 0
5262 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5263 && htab
->elf
.splt
->output_section
!= NULL
5264 && htab
->plt_eh_frame
->output_section
!= NULL
)
5266 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5267 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5268 + htab
->plt_eh_frame
->output_offset
5269 + PLT_FDE_START_OFFSET
;
5270 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5271 htab
->plt_eh_frame
->contents
5272 + PLT_FDE_START_OFFSET
);
5274 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5276 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5278 htab
->plt_eh_frame
->contents
))
5283 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5284 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5287 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5288 htab_traverse (htab
->loc_hash_table
,
5289 elf_x86_64_finish_local_dynamic_symbol
,
5295 /* Return address in section PLT for the Ith GOTPLT relocation, for
5296 relocation REL or (bfd_vma) -1 if it should not be included. */
5299 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
5303 const struct elf_x86_64_backend_data
*bed
;
5306 /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE. */
5307 if (rel
->howto
->type
!= R_X86_64_JUMP_SLOT
5308 && rel
->howto
->type
!= R_X86_64_IRELATIVE
)
5309 return (bfd_vma
) -1;
5312 bed
= get_elf_x86_64_backend_data (abfd
);
5313 plt_offset
= bed
->plt_entry_size
;
5315 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5316 return plt
->vma
+ (i
+ 1) * plt_offset
;
5318 while (plt_offset
< plt
->size
)
5320 bfd_vma reloc_index
;
5321 bfd_byte reloc_index_raw
[4];
5323 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5325 plt_offset
+ bed
->plt_reloc_offset
,
5326 sizeof (reloc_index_raw
)))
5327 return (bfd_vma
) -1;
5329 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5330 if (reloc_index
== i
)
5331 return plt
->vma
+ plt_offset
;
5332 plt_offset
+= bed
->plt_entry_size
;
5338 /* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
5339 PLT section, or (bfd_vma) -1 if it should not be included. */
5342 elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i
, const asection
*plt
)
5344 const struct elf_x86_64_backend_data
*bed
= &elf_x86_64_bnd_arch_bed
;
5345 bfd
*abfd
= plt
->owner
;
5346 bfd_vma plt_offset
= bed
->plt_entry_size
;
5348 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5349 return i
* sizeof (elf_x86_64_legacy_plt2_entry
);
5351 while (plt_offset
< plt
->size
)
5353 bfd_vma reloc_index
;
5354 bfd_byte reloc_index_raw
[4];
5356 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5358 plt_offset
+ bed
->plt_reloc_offset
,
5359 sizeof (reloc_index_raw
)))
5360 return (bfd_vma
) -1;
5362 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5363 if (reloc_index
== i
)
5365 /* This is the index in .plt section. */
5366 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5367 /* Return the offset in .plt.bnd section. */
5368 return (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
);
5370 plt_offset
+= bed
->plt_entry_size
;
5376 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5380 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5387 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5390 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5394 Elf_Internal_Shdr
*hdr
;
5396 asection
*plt
, *plt_push
;
5398 plt_push
= bfd_get_section_by_name (abfd
, ".plt");
5399 if (plt_push
== NULL
)
5402 plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5403 /* Use the generic ELF version if there is no .plt.bnd section. */
5405 return _bfd_elf_get_synthetic_symtab (abfd
, symcount
, syms
,
5406 dynsymcount
, dynsyms
, ret
);
5410 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
5413 if (dynsymcount
<= 0)
5416 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
5420 hdr
= &elf_section_data (relplt
)->this_hdr
;
5421 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
5422 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
5425 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5426 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5429 count
= relplt
->size
/ hdr
->sh_entsize
;
5430 size
= count
* sizeof (asymbol
);
5431 p
= relplt
->relocation
;
5432 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
5434 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
5436 size
+= sizeof ("+0x") - 1 + 8 + 8;
5439 s
= *ret
= (asymbol
*) bfd_malloc (size
);
5443 names
= (char *) (s
+ count
);
5444 p
= relplt
->relocation
;
5446 for (i
= 0; i
< count
; i
++, p
++)
5451 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5452 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5455 offset
= elf_x86_64_plt_sym_val_offset_plt_bnd (i
, plt_push
);
5457 *s
= **p
->sym_ptr_ptr
;
5458 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
5459 we are defining a symbol, ensure one of them is set. */
5460 if ((s
->flags
& BSF_LOCAL
) == 0)
5461 s
->flags
|= BSF_GLOBAL
;
5462 s
->flags
|= BSF_SYNTHETIC
;
5467 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
5468 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
5474 memcpy (names
, "+0x", sizeof ("+0x") - 1);
5475 names
+= sizeof ("+0x") - 1;
5476 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
5477 for (a
= buf
; *a
== '0'; ++a
)
5480 memcpy (names
, a
, len
);
5483 memcpy (names
, "@plt", sizeof ("@plt"));
5484 names
+= sizeof ("@plt");
5491 /* Handle an x86-64 specific section when reading an object file. This
5492 is called when elfcode.h finds a section with an unknown type. */
5495 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5496 const char *name
, int shindex
)
5498 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5501 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5507 /* Hook called by the linker routine which adds symbols from an object
5508 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5512 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5513 struct bfd_link_info
*info
,
5514 Elf_Internal_Sym
*sym
,
5515 const char **namep ATTRIBUTE_UNUSED
,
5516 flagword
*flagsp ATTRIBUTE_UNUSED
,
5522 switch (sym
->st_shndx
)
5524 case SHN_X86_64_LCOMMON
:
5525 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5528 lcomm
= bfd_make_section_with_flags (abfd
,
5532 | SEC_LINKER_CREATED
));
5535 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5538 *valp
= sym
->st_size
;
5542 if ((abfd
->flags
& DYNAMIC
) == 0
5543 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5544 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
5545 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5551 /* Given a BFD section, try to locate the corresponding ELF section
5555 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5556 asection
*sec
, int *index_return
)
5558 if (sec
== &_bfd_elf_large_com_section
)
5560 *index_return
= SHN_X86_64_LCOMMON
;
5566 /* Process a symbol. */
5569 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5572 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5574 switch (elfsym
->internal_elf_sym
.st_shndx
)
5576 case SHN_X86_64_LCOMMON
:
5577 asym
->section
= &_bfd_elf_large_com_section
;
5578 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5579 /* Common symbol doesn't set BSF_GLOBAL. */
5580 asym
->flags
&= ~BSF_GLOBAL
;
5586 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5588 return (sym
->st_shndx
== SHN_COMMON
5589 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5593 elf_x86_64_common_section_index (asection
*sec
)
5595 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5598 return SHN_X86_64_LCOMMON
;
5602 elf_x86_64_common_section (asection
*sec
)
5604 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5605 return bfd_com_section_ptr
;
5607 return &_bfd_elf_large_com_section
;
5611 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5612 const Elf_Internal_Sym
*sym
,
5617 const asection
*oldsec
)
5619 /* A normal common symbol and a large common symbol result in a
5620 normal common symbol. We turn the large common symbol into a
5623 && h
->root
.type
== bfd_link_hash_common
5625 && bfd_is_com_section (*psec
)
5628 if (sym
->st_shndx
== SHN_COMMON
5629 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5631 h
->root
.u
.c
.p
->section
5632 = bfd_make_section_old_way (oldbfd
, "COMMON");
5633 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5635 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5636 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5637 *psec
= bfd_com_section_ptr
;
5644 elf_x86_64_additional_program_headers (bfd
*abfd
,
5645 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5650 /* Check to see if we need a large readonly segment. */
5651 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5652 if (s
&& (s
->flags
& SEC_LOAD
))
5655 /* Check to see if we need a large data segment. Since .lbss sections
5656 is placed right after the .bss section, there should be no need for
5657 a large data segment just because of .lbss. */
5658 s
= bfd_get_section_by_name (abfd
, ".ldata");
5659 if (s
&& (s
->flags
& SEC_LOAD
))
5665 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5668 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5670 if (h
->plt
.offset
!= (bfd_vma
) -1
5672 && !h
->pointer_equality_needed
)
5675 return _bfd_elf_hash_symbol (h
);
5678 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5681 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5682 const bfd_target
*output
)
5684 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5685 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5686 && _bfd_elf_relocs_compatible (input
, output
));
5689 static const struct bfd_elf_special_section
5690 elf_x86_64_special_sections
[]=
5692 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5693 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5694 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5695 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5696 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5697 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5698 { NULL
, 0, 0, 0, 0 }
5701 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5702 #define TARGET_LITTLE_NAME "elf64-x86-64"
5703 #define ELF_ARCH bfd_arch_i386
5704 #define ELF_TARGET_ID X86_64_ELF_DATA
5705 #define ELF_MACHINE_CODE EM_X86_64
5706 #define ELF_MAXPAGESIZE 0x200000
5707 #define ELF_MINPAGESIZE 0x1000
5708 #define ELF_COMMONPAGESIZE 0x1000
5710 #define elf_backend_can_gc_sections 1
5711 #define elf_backend_can_refcount 1
5712 #define elf_backend_want_got_plt 1
5713 #define elf_backend_plt_readonly 1
5714 #define elf_backend_want_plt_sym 0
5715 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5716 #define elf_backend_rela_normal 1
5717 #define elf_backend_plt_alignment 4
5719 #define elf_info_to_howto elf_x86_64_info_to_howto
5721 #define bfd_elf64_bfd_link_hash_table_create \
5722 elf_x86_64_link_hash_table_create
5723 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5724 #define bfd_elf64_bfd_reloc_name_lookup \
5725 elf_x86_64_reloc_name_lookup
5727 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5728 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5729 #define elf_backend_check_relocs elf_x86_64_check_relocs
5730 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5731 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5732 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5733 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5734 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5735 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5736 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5737 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5739 #define elf_backend_write_core_note elf_x86_64_write_core_note
5741 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5742 #define elf_backend_relocate_section elf_x86_64_relocate_section
5743 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5744 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5745 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5746 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5747 #define elf_backend_object_p elf64_x86_64_elf_object_p
5748 #define bfd_elf64_mkobject elf_x86_64_mkobject
5749 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5751 #define elf_backend_section_from_shdr \
5752 elf_x86_64_section_from_shdr
5754 #define elf_backend_section_from_bfd_section \
5755 elf_x86_64_elf_section_from_bfd_section
5756 #define elf_backend_add_symbol_hook \
5757 elf_x86_64_add_symbol_hook
5758 #define elf_backend_symbol_processing \
5759 elf_x86_64_symbol_processing
5760 #define elf_backend_common_section_index \
5761 elf_x86_64_common_section_index
5762 #define elf_backend_common_section \
5763 elf_x86_64_common_section
5764 #define elf_backend_common_definition \
5765 elf_x86_64_common_definition
5766 #define elf_backend_merge_symbol \
5767 elf_x86_64_merge_symbol
5768 #define elf_backend_special_sections \
5769 elf_x86_64_special_sections
5770 #define elf_backend_additional_program_headers \
5771 elf_x86_64_additional_program_headers
5772 #define elf_backend_hash_symbol \
5773 elf_x86_64_hash_symbol
5775 #include "elf64-target.h"
5777 /* FreeBSD support. */
5779 #undef TARGET_LITTLE_SYM
5780 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5781 #undef TARGET_LITTLE_NAME
5782 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5785 #define ELF_OSABI ELFOSABI_FREEBSD
5788 #define elf64_bed elf64_x86_64_fbsd_bed
5790 #include "elf64-target.h"
5792 /* Solaris 2 support. */
5794 #undef TARGET_LITTLE_SYM
5795 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5796 #undef TARGET_LITTLE_NAME
5797 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5799 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5800 objects won't be recognized. */
5804 #define elf64_bed elf64_x86_64_sol2_bed
5806 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5808 #undef elf_backend_static_tls_alignment
5809 #define elf_backend_static_tls_alignment 16
5811 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5813 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5815 #undef elf_backend_want_plt_sym
5816 #define elf_backend_want_plt_sym 1
5818 #include "elf64-target.h"
5820 #undef bfd_elf64_get_synthetic_symtab
5822 /* Native Client support. */
5825 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
5827 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5828 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
5832 #undef TARGET_LITTLE_SYM
5833 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5834 #undef TARGET_LITTLE_NAME
5835 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5837 #define elf64_bed elf64_x86_64_nacl_bed
5839 #undef ELF_MAXPAGESIZE
5840 #undef ELF_MINPAGESIZE
5841 #undef ELF_COMMONPAGESIZE
5842 #define ELF_MAXPAGESIZE 0x10000
5843 #define ELF_MINPAGESIZE 0x10000
5844 #define ELF_COMMONPAGESIZE 0x10000
5846 /* Restore defaults. */
5848 #undef elf_backend_static_tls_alignment
5849 #undef elf_backend_want_plt_sym
5850 #define elf_backend_want_plt_sym 0
5852 /* NaCl uses substantially different PLT entries for the same effects. */
5854 #undef elf_backend_plt_alignment
5855 #define elf_backend_plt_alignment 5
5856 #define NACL_PLT_ENTRY_SIZE 64
5857 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5859 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5861 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5862 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5863 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5864 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5865 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5867 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5868 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5870 /* 32 bytes of nop to pad out to the standard size. */
5871 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5872 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5873 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5874 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5875 0x66, /* excess data32 prefix */
5879 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5881 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5882 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5883 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5884 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5886 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5887 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5888 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5890 /* Lazy GOT entries point here (32-byte aligned). */
5891 0x68, /* pushq immediate */
5892 0, 0, 0, 0, /* replaced with index into relocation table. */
5893 0xe9, /* jmp relative */
5894 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5896 /* 22 bytes of nop to pad out to the standard size. */
5897 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5898 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5899 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5902 /* .eh_frame covering the .plt section. */
5904 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5906 #if (PLT_CIE_LENGTH != 20 \
5907 || PLT_FDE_LENGTH != 36 \
5908 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5909 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5910 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5912 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5913 0, 0, 0, 0, /* CIE ID */
5914 1, /* CIE version */
5915 'z', 'R', 0, /* Augmentation string */
5916 1, /* Code alignment factor */
5917 0x78, /* Data alignment factor */
5918 16, /* Return address column */
5919 1, /* Augmentation size */
5920 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5921 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5922 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5923 DW_CFA_nop
, DW_CFA_nop
,
5925 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5926 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5927 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5928 0, 0, 0, 0, /* .plt size goes here */
5929 0, /* Augmentation size */
5930 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5931 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5932 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5933 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5934 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5935 13, /* Block length */
5936 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5937 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5938 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5939 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5940 DW_CFA_nop
, DW_CFA_nop
5943 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5945 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5946 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5947 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5948 2, /* plt0_got1_offset */
5949 9, /* plt0_got2_offset */
5950 13, /* plt0_got2_insn_end */
5951 3, /* plt_got_offset */
5952 33, /* plt_reloc_offset */
5953 38, /* plt_plt_offset */
5954 7, /* plt_got_insn_size */
5955 42, /* plt_plt_insn_end */
5956 32, /* plt_lazy_offset */
5957 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5958 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5961 #undef elf_backend_arch_data
5962 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5964 #undef elf_backend_object_p
5965 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5966 #undef elf_backend_modify_segment_map
5967 #define elf_backend_modify_segment_map nacl_modify_segment_map
5968 #undef elf_backend_modify_program_headers
5969 #define elf_backend_modify_program_headers nacl_modify_program_headers
5970 #undef elf_backend_final_write_processing
5971 #define elf_backend_final_write_processing nacl_final_write_processing
5973 #include "elf64-target.h"
5975 /* Native Client x32 support. */
5978 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
5980 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5981 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
5985 #undef TARGET_LITTLE_SYM
5986 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5987 #undef TARGET_LITTLE_NAME
5988 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5990 #define elf32_bed elf32_x86_64_nacl_bed
5992 #define bfd_elf32_bfd_link_hash_table_create \
5993 elf_x86_64_link_hash_table_create
5994 #define bfd_elf32_bfd_reloc_type_lookup \
5995 elf_x86_64_reloc_type_lookup
5996 #define bfd_elf32_bfd_reloc_name_lookup \
5997 elf_x86_64_reloc_name_lookup
5998 #define bfd_elf32_mkobject \
6001 #undef elf_backend_object_p
6002 #define elf_backend_object_p \
6003 elf32_x86_64_nacl_elf_object_p
6005 #undef elf_backend_bfd_from_remote_memory
6006 #define elf_backend_bfd_from_remote_memory \
6007 _bfd_elf32_bfd_from_remote_memory
6009 #undef elf_backend_size_info
6010 #define elf_backend_size_info \
6011 _bfd_elf32_size_info
6013 #include "elf32-target.h"
6015 /* Restore defaults. */
6016 #undef elf_backend_object_p
6017 #define elf_backend_object_p elf64_x86_64_elf_object_p
6018 #undef elf_backend_bfd_from_remote_memory
6019 #undef elf_backend_size_info
6020 #undef elf_backend_modify_segment_map
6021 #undef elf_backend_modify_program_headers
6022 #undef elf_backend_final_write_processing
6024 /* Intel L1OM support. */
6027 elf64_l1om_elf_object_p (bfd
*abfd
)
6029 /* Set the right machine number for an L1OM elf64 file. */
6030 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6034 #undef TARGET_LITTLE_SYM
6035 #define TARGET_LITTLE_SYM l1om_elf64_vec
6036 #undef TARGET_LITTLE_NAME
6037 #define TARGET_LITTLE_NAME "elf64-l1om"
6039 #define ELF_ARCH bfd_arch_l1om
6041 #undef ELF_MACHINE_CODE
6042 #define ELF_MACHINE_CODE EM_L1OM
6047 #define elf64_bed elf64_l1om_bed
6049 #undef elf_backend_object_p
6050 #define elf_backend_object_p elf64_l1om_elf_object_p
6052 /* Restore defaults. */
6053 #undef ELF_MAXPAGESIZE
6054 #undef ELF_MINPAGESIZE
6055 #undef ELF_COMMONPAGESIZE
6056 #define ELF_MAXPAGESIZE 0x200000
6057 #define ELF_MINPAGESIZE 0x1000
6058 #define ELF_COMMONPAGESIZE 0x1000
6059 #undef elf_backend_plt_alignment
6060 #define elf_backend_plt_alignment 4
6061 #undef elf_backend_arch_data
6062 #define elf_backend_arch_data &elf_x86_64_arch_bed
6064 #include "elf64-target.h"
6066 /* FreeBSD L1OM support. */
6068 #undef TARGET_LITTLE_SYM
6069 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6070 #undef TARGET_LITTLE_NAME
6071 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6074 #define ELF_OSABI ELFOSABI_FREEBSD
6077 #define elf64_bed elf64_l1om_fbsd_bed
6079 #include "elf64-target.h"
6081 /* Intel K1OM support. */
6084 elf64_k1om_elf_object_p (bfd
*abfd
)
6086 /* Set the right machine number for an K1OM elf64 file. */
6087 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6091 #undef TARGET_LITTLE_SYM
6092 #define TARGET_LITTLE_SYM k1om_elf64_vec
6093 #undef TARGET_LITTLE_NAME
6094 #define TARGET_LITTLE_NAME "elf64-k1om"
6096 #define ELF_ARCH bfd_arch_k1om
6098 #undef ELF_MACHINE_CODE
6099 #define ELF_MACHINE_CODE EM_K1OM
6104 #define elf64_bed elf64_k1om_bed
6106 #undef elf_backend_object_p
6107 #define elf_backend_object_p elf64_k1om_elf_object_p
6109 #undef elf_backend_static_tls_alignment
6111 #undef elf_backend_want_plt_sym
6112 #define elf_backend_want_plt_sym 0
6114 #include "elf64-target.h"
6116 /* FreeBSD K1OM support. */
6118 #undef TARGET_LITTLE_SYM
6119 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6120 #undef TARGET_LITTLE_NAME
6121 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6124 #define ELF_OSABI ELFOSABI_FREEBSD
6127 #define elf64_bed elf64_k1om_fbsd_bed
6129 #include "elf64-target.h"
6131 /* 32bit x86-64 support. */
6133 #undef TARGET_LITTLE_SYM
6134 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6135 #undef TARGET_LITTLE_NAME
6136 #define TARGET_LITTLE_NAME "elf32-x86-64"
6140 #define ELF_ARCH bfd_arch_i386
6142 #undef ELF_MACHINE_CODE
6143 #define ELF_MACHINE_CODE EM_X86_64
6147 #undef elf_backend_object_p
6148 #define elf_backend_object_p \
6149 elf32_x86_64_elf_object_p
6151 #undef elf_backend_bfd_from_remote_memory
6152 #define elf_backend_bfd_from_remote_memory \
6153 _bfd_elf32_bfd_from_remote_memory
6155 #undef elf_backend_size_info
6156 #define elf_backend_size_info \
6157 _bfd_elf32_size_info
6159 #include "elf32-target.h"