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 GOT PLT entry. Filled when there are both
764 GOT and PLT relocations against the same function. */
765 union gotplt_union plt_got
;
767 /* Information about the second PLT entry. Filled when has_bnd_reloc is
769 union gotplt_union plt_bnd
;
771 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
772 starting at the end of the jump table. */
776 #define elf_x86_64_hash_entry(ent) \
777 ((struct elf_x86_64_link_hash_entry *)(ent))
779 struct elf_x86_64_obj_tdata
781 struct elf_obj_tdata root
;
783 /* tls_type for each local got entry. */
784 char *local_got_tls_type
;
786 /* GOTPLT entries for TLS descriptors. */
787 bfd_vma
*local_tlsdesc_gotent
;
790 #define elf_x86_64_tdata(abfd) \
791 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
793 #define elf_x86_64_local_got_tls_type(abfd) \
794 (elf_x86_64_tdata (abfd)->local_got_tls_type)
796 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
797 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
799 #define is_x86_64_elf(bfd) \
800 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
801 && elf_tdata (bfd) != NULL \
802 && elf_object_id (bfd) == X86_64_ELF_DATA)
805 elf_x86_64_mkobject (bfd
*abfd
)
807 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
811 /* x86-64 ELF linker hash table. */
813 struct elf_x86_64_link_hash_table
815 struct elf_link_hash_table elf
;
817 /* Short-cuts to get to dynamic linker sections. */
820 asection
*plt_eh_frame
;
826 bfd_signed_vma refcount
;
830 /* The amount of space used by the jump slots in the GOT. */
831 bfd_vma sgotplt_jump_table_size
;
833 /* Small local sym cache. */
834 struct sym_cache sym_cache
;
836 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
837 bfd_vma (*r_sym
) (bfd_vma
);
838 unsigned int pointer_r_type
;
839 const char *dynamic_interpreter
;
840 int dynamic_interpreter_size
;
842 /* _TLS_MODULE_BASE_ symbol. */
843 struct bfd_link_hash_entry
*tls_module_base
;
845 /* Used by local STT_GNU_IFUNC symbols. */
846 htab_t loc_hash_table
;
847 void * loc_hash_memory
;
849 /* The offset into splt of the PLT entry for the TLS descriptor
850 resolver. Special values are 0, if not necessary (or not found
851 to be necessary yet), and -1 if needed but not determined
854 /* The offset into sgot of the GOT entry used by the PLT entry
858 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
859 bfd_vma next_jump_slot_index
;
860 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
861 bfd_vma next_irelative_index
;
864 /* Get the x86-64 ELF linker hash table from a link_info structure. */
866 #define elf_x86_64_hash_table(p) \
867 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
868 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
870 #define elf_x86_64_compute_jump_table_size(htab) \
871 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
873 /* Create an entry in an x86-64 ELF linker hash table. */
875 static struct bfd_hash_entry
*
876 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
877 struct bfd_hash_table
*table
,
880 /* Allocate the structure if it has not already been allocated by a
884 entry
= (struct bfd_hash_entry
*)
885 bfd_hash_allocate (table
,
886 sizeof (struct elf_x86_64_link_hash_entry
));
891 /* Call the allocation method of the superclass. */
892 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
895 struct elf_x86_64_link_hash_entry
*eh
;
897 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
898 eh
->dyn_relocs
= NULL
;
899 eh
->tls_type
= GOT_UNKNOWN
;
900 eh
->has_bnd_reloc
= FALSE
;
901 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
902 eh
->plt_got
.offset
= (bfd_vma
) -1;
903 eh
->tlsdesc_got
= (bfd_vma
) -1;
909 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
910 for local symbol so that we can handle local STT_GNU_IFUNC symbols
911 as global symbol. We reuse indx and dynstr_index for local symbol
912 hash since they aren't used by global symbols in this backend. */
915 elf_x86_64_local_htab_hash (const void *ptr
)
917 struct elf_link_hash_entry
*h
918 = (struct elf_link_hash_entry
*) ptr
;
919 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
922 /* Compare local hash entries. */
925 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
927 struct elf_link_hash_entry
*h1
928 = (struct elf_link_hash_entry
*) ptr1
;
929 struct elf_link_hash_entry
*h2
930 = (struct elf_link_hash_entry
*) ptr2
;
932 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
935 /* Find and/or create a hash entry for local symbol. */
937 static struct elf_link_hash_entry
*
938 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
939 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
942 struct elf_x86_64_link_hash_entry e
, *ret
;
943 asection
*sec
= abfd
->sections
;
944 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
945 htab
->r_sym (rel
->r_info
));
948 e
.elf
.indx
= sec
->id
;
949 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
950 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
951 create
? INSERT
: NO_INSERT
);
958 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
962 ret
= (struct elf_x86_64_link_hash_entry
*)
963 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
964 sizeof (struct elf_x86_64_link_hash_entry
));
967 memset (ret
, 0, sizeof (*ret
));
968 ret
->elf
.indx
= sec
->id
;
969 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
970 ret
->elf
.dynindx
= -1;
971 ret
->plt_got
.offset
= (bfd_vma
) -1;
977 /* Destroy an X86-64 ELF linker hash table. */
980 elf_x86_64_link_hash_table_free (bfd
*obfd
)
982 struct elf_x86_64_link_hash_table
*htab
983 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
985 if (htab
->loc_hash_table
)
986 htab_delete (htab
->loc_hash_table
);
987 if (htab
->loc_hash_memory
)
988 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
989 _bfd_elf_link_hash_table_free (obfd
);
992 /* Create an X86-64 ELF linker hash table. */
994 static struct bfd_link_hash_table
*
995 elf_x86_64_link_hash_table_create (bfd
*abfd
)
997 struct elf_x86_64_link_hash_table
*ret
;
998 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1000 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1004 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1005 elf_x86_64_link_hash_newfunc
,
1006 sizeof (struct elf_x86_64_link_hash_entry
),
1013 if (ABI_64_P (abfd
))
1015 ret
->r_info
= elf64_r_info
;
1016 ret
->r_sym
= elf64_r_sym
;
1017 ret
->pointer_r_type
= R_X86_64_64
;
1018 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1019 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1023 ret
->r_info
= elf32_r_info
;
1024 ret
->r_sym
= elf32_r_sym
;
1025 ret
->pointer_r_type
= R_X86_64_32
;
1026 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1027 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1030 ret
->loc_hash_table
= htab_try_create (1024,
1031 elf_x86_64_local_htab_hash
,
1032 elf_x86_64_local_htab_eq
,
1034 ret
->loc_hash_memory
= objalloc_create ();
1035 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1037 elf_x86_64_link_hash_table_free (abfd
);
1040 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1042 return &ret
->elf
.root
;
1045 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1046 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1050 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1051 struct bfd_link_info
*info
)
1053 struct elf_x86_64_link_hash_table
*htab
;
1055 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1058 htab
= elf_x86_64_hash_table (info
);
1062 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1064 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
1067 || (!info
->shared
&& !htab
->srelbss
))
1070 if (!info
->no_ld_generated_unwind_info
1071 && htab
->plt_eh_frame
== NULL
1072 && htab
->elf
.splt
!= NULL
)
1074 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1075 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1076 | SEC_LINKER_CREATED
);
1078 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1079 if (htab
->plt_eh_frame
== NULL
1080 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1086 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1089 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1090 struct elf_link_hash_entry
*dir
,
1091 struct elf_link_hash_entry
*ind
)
1093 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1095 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1096 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1098 if (!edir
->has_bnd_reloc
)
1099 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1101 if (eind
->dyn_relocs
!= NULL
)
1103 if (edir
->dyn_relocs
!= NULL
)
1105 struct elf_dyn_relocs
**pp
;
1106 struct elf_dyn_relocs
*p
;
1108 /* Add reloc counts against the indirect sym to the direct sym
1109 list. Merge any entries against the same section. */
1110 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1112 struct elf_dyn_relocs
*q
;
1114 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1115 if (q
->sec
== p
->sec
)
1117 q
->pc_count
+= p
->pc_count
;
1118 q
->count
+= p
->count
;
1125 *pp
= edir
->dyn_relocs
;
1128 edir
->dyn_relocs
= eind
->dyn_relocs
;
1129 eind
->dyn_relocs
= NULL
;
1132 if (ind
->root
.type
== bfd_link_hash_indirect
1133 && dir
->got
.refcount
<= 0)
1135 edir
->tls_type
= eind
->tls_type
;
1136 eind
->tls_type
= GOT_UNKNOWN
;
1139 if (ELIMINATE_COPY_RELOCS
1140 && ind
->root
.type
!= bfd_link_hash_indirect
1141 && dir
->dynamic_adjusted
)
1143 /* If called to transfer flags for a weakdef during processing
1144 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1145 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1146 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1147 dir
->ref_regular
|= ind
->ref_regular
;
1148 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1149 dir
->needs_plt
|= ind
->needs_plt
;
1150 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1153 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1157 elf64_x86_64_elf_object_p (bfd
*abfd
)
1159 /* Set the right machine number for an x86-64 elf64 file. */
1160 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1165 elf32_x86_64_elf_object_p (bfd
*abfd
)
1167 /* Set the right machine number for an x86-64 elf32 file. */
1168 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1172 /* Return TRUE if the TLS access code sequence support transition
1176 elf_x86_64_check_tls_transition (bfd
*abfd
,
1177 struct bfd_link_info
*info
,
1180 Elf_Internal_Shdr
*symtab_hdr
,
1181 struct elf_link_hash_entry
**sym_hashes
,
1182 unsigned int r_type
,
1183 const Elf_Internal_Rela
*rel
,
1184 const Elf_Internal_Rela
*relend
)
1187 unsigned long r_symndx
;
1188 bfd_boolean largepic
= FALSE
;
1189 struct elf_link_hash_entry
*h
;
1191 struct elf_x86_64_link_hash_table
*htab
;
1193 /* Get the section contents. */
1194 if (contents
== NULL
)
1196 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1197 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1200 /* FIXME: How to better handle error condition? */
1201 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1204 /* Cache the section contents for elf_link_input_bfd. */
1205 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1209 htab
= elf_x86_64_hash_table (info
);
1210 offset
= rel
->r_offset
;
1213 case R_X86_64_TLSGD
:
1214 case R_X86_64_TLSLD
:
1215 if ((rel
+ 1) >= relend
)
1218 if (r_type
== R_X86_64_TLSGD
)
1220 /* Check transition from GD access model. For 64bit, only
1221 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1222 .word 0x6666; rex64; call __tls_get_addr
1223 can transit to different access model. For 32bit, only
1224 leaq foo@tlsgd(%rip), %rdi
1225 .word 0x6666; rex64; call __tls_get_addr
1226 can transit to different access model. For largepic
1228 leaq foo@tlsgd(%rip), %rdi
1229 movabsq $__tls_get_addr@pltoff, %rax
1233 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1234 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1236 if ((offset
+ 12) > sec
->size
)
1239 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1241 if (!ABI_64_P (abfd
)
1242 || (offset
+ 19) > sec
->size
1244 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1245 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1246 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1251 else if (ABI_64_P (abfd
))
1254 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1260 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1266 /* Check transition from LD access model. Only
1267 leaq foo@tlsld(%rip), %rdi;
1269 can transit to different access model. For largepic
1271 leaq foo@tlsld(%rip), %rdi
1272 movabsq $__tls_get_addr@pltoff, %rax
1276 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1278 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1281 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1284 if (0xe8 != *(contents
+ offset
+ 4))
1286 if (!ABI_64_P (abfd
)
1287 || (offset
+ 19) > sec
->size
1288 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1289 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1296 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1297 if (r_symndx
< symtab_hdr
->sh_info
)
1300 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1301 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1302 may be versioned. */
1304 && h
->root
.root
.string
!= NULL
1306 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1307 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1308 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1309 && (strncmp (h
->root
.root
.string
,
1310 "__tls_get_addr", 14) == 0));
1312 case R_X86_64_GOTTPOFF
:
1313 /* Check transition from IE access model:
1314 mov foo@gottpoff(%rip), %reg
1315 add foo@gottpoff(%rip), %reg
1318 /* Check REX prefix first. */
1319 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1321 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1322 if (val
!= 0x48 && val
!= 0x4c)
1324 /* X32 may have 0x44 REX prefix or no REX prefix. */
1325 if (ABI_64_P (abfd
))
1331 /* X32 may not have any REX prefix. */
1332 if (ABI_64_P (abfd
))
1334 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1338 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1339 if (val
!= 0x8b && val
!= 0x03)
1342 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1343 return (val
& 0xc7) == 5;
1345 case R_X86_64_GOTPC32_TLSDESC
:
1346 /* Check transition from GDesc access model:
1347 leaq x@tlsdesc(%rip), %rax
1349 Make sure it's a leaq adding rip to a 32-bit offset
1350 into any register, although it's probably almost always
1353 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1356 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1357 if ((val
& 0xfb) != 0x48)
1360 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1363 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1364 return (val
& 0xc7) == 0x05;
1366 case R_X86_64_TLSDESC_CALL
:
1367 /* Check transition from GDesc access model:
1368 call *x@tlsdesc(%rax)
1370 if (offset
+ 2 <= sec
->size
)
1372 /* Make sure that it's a call *x@tlsdesc(%rax). */
1373 static const unsigned char call
[] = { 0xff, 0x10 };
1374 return memcmp (contents
+ offset
, call
, 2) == 0;
1384 /* Return TRUE if the TLS access transition is OK or no transition
1385 will be performed. Update R_TYPE if there is a transition. */
1388 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1389 asection
*sec
, bfd_byte
*contents
,
1390 Elf_Internal_Shdr
*symtab_hdr
,
1391 struct elf_link_hash_entry
**sym_hashes
,
1392 unsigned int *r_type
, int tls_type
,
1393 const Elf_Internal_Rela
*rel
,
1394 const Elf_Internal_Rela
*relend
,
1395 struct elf_link_hash_entry
*h
,
1396 unsigned long r_symndx
)
1398 unsigned int from_type
= *r_type
;
1399 unsigned int to_type
= from_type
;
1400 bfd_boolean check
= TRUE
;
1402 /* Skip TLS transition for functions. */
1404 && (h
->type
== STT_FUNC
1405 || h
->type
== STT_GNU_IFUNC
))
1410 case R_X86_64_TLSGD
:
1411 case R_X86_64_GOTPC32_TLSDESC
:
1412 case R_X86_64_TLSDESC_CALL
:
1413 case R_X86_64_GOTTPOFF
:
1414 if (info
->executable
)
1417 to_type
= R_X86_64_TPOFF32
;
1419 to_type
= R_X86_64_GOTTPOFF
;
1422 /* When we are called from elf_x86_64_relocate_section,
1423 CONTENTS isn't NULL and there may be additional transitions
1424 based on TLS_TYPE. */
1425 if (contents
!= NULL
)
1427 unsigned int new_to_type
= to_type
;
1429 if (info
->executable
1432 && tls_type
== GOT_TLS_IE
)
1433 new_to_type
= R_X86_64_TPOFF32
;
1435 if (to_type
== R_X86_64_TLSGD
1436 || to_type
== R_X86_64_GOTPC32_TLSDESC
1437 || to_type
== R_X86_64_TLSDESC_CALL
)
1439 if (tls_type
== GOT_TLS_IE
)
1440 new_to_type
= R_X86_64_GOTTPOFF
;
1443 /* We checked the transition before when we were called from
1444 elf_x86_64_check_relocs. We only want to check the new
1445 transition which hasn't been checked before. */
1446 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1447 to_type
= new_to_type
;
1452 case R_X86_64_TLSLD
:
1453 if (info
->executable
)
1454 to_type
= R_X86_64_TPOFF32
;
1461 /* Return TRUE if there is no transition. */
1462 if (from_type
== to_type
)
1465 /* Check if the transition can be performed. */
1467 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1468 symtab_hdr
, sym_hashes
,
1469 from_type
, rel
, relend
))
1471 reloc_howto_type
*from
, *to
;
1474 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1475 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1478 name
= h
->root
.root
.string
;
1481 struct elf_x86_64_link_hash_table
*htab
;
1483 htab
= elf_x86_64_hash_table (info
);
1488 Elf_Internal_Sym
*isym
;
1490 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1492 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1496 (*_bfd_error_handler
)
1497 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1498 "in section `%A' failed"),
1499 abfd
, sec
, from
->name
, to
->name
, name
,
1500 (unsigned long) rel
->r_offset
);
1501 bfd_set_error (bfd_error_bad_value
);
1509 /* Look through the relocs for a section during the first phase, and
1510 calculate needed space in the global offset table, procedure
1511 linkage table, and dynamic reloc sections. */
1514 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1516 const Elf_Internal_Rela
*relocs
)
1518 struct elf_x86_64_link_hash_table
*htab
;
1519 Elf_Internal_Shdr
*symtab_hdr
;
1520 struct elf_link_hash_entry
**sym_hashes
;
1521 const Elf_Internal_Rela
*rel
;
1522 const Elf_Internal_Rela
*rel_end
;
1524 bfd_boolean use_plt_got
;
1526 if (info
->relocatable
)
1529 BFD_ASSERT (is_x86_64_elf (abfd
));
1531 htab
= elf_x86_64_hash_table (info
);
1535 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1537 symtab_hdr
= &elf_symtab_hdr (abfd
);
1538 sym_hashes
= elf_sym_hashes (abfd
);
1542 rel_end
= relocs
+ sec
->reloc_count
;
1543 for (rel
= relocs
; rel
< rel_end
; rel
++)
1545 unsigned int r_type
;
1546 unsigned long r_symndx
;
1547 struct elf_link_hash_entry
*h
;
1548 Elf_Internal_Sym
*isym
;
1550 bfd_boolean size_reloc
;
1552 r_symndx
= htab
->r_sym (rel
->r_info
);
1553 r_type
= ELF32_R_TYPE (rel
->r_info
);
1555 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1557 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1562 if (r_symndx
< symtab_hdr
->sh_info
)
1564 /* A local symbol. */
1565 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1570 /* Check relocation against local STT_GNU_IFUNC symbol. */
1571 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1573 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1578 /* Fake a STT_GNU_IFUNC symbol. */
1579 h
->type
= STT_GNU_IFUNC
;
1582 h
->forced_local
= 1;
1583 h
->root
.type
= bfd_link_hash_defined
;
1591 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1592 while (h
->root
.type
== bfd_link_hash_indirect
1593 || h
->root
.type
== bfd_link_hash_warning
)
1594 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1597 /* Check invalid x32 relocations. */
1598 if (!ABI_64_P (abfd
))
1604 case R_X86_64_DTPOFF64
:
1605 case R_X86_64_TPOFF64
:
1607 case R_X86_64_GOTOFF64
:
1608 case R_X86_64_GOT64
:
1609 case R_X86_64_GOTPCREL64
:
1610 case R_X86_64_GOTPC64
:
1611 case R_X86_64_GOTPLT64
:
1612 case R_X86_64_PLTOFF64
:
1615 name
= h
->root
.root
.string
;
1617 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1619 (*_bfd_error_handler
)
1620 (_("%B: relocation %s against symbol `%s' isn't "
1621 "supported in x32 mode"), abfd
,
1622 x86_64_elf_howto_table
[r_type
].name
, name
);
1623 bfd_set_error (bfd_error_bad_value
);
1631 /* Create the ifunc sections for static executables. If we
1632 never see an indirect function symbol nor we are building
1633 a static executable, those sections will be empty and
1634 won't appear in output. */
1640 case R_X86_64_PC32_BND
:
1641 case R_X86_64_PLT32_BND
:
1643 case R_X86_64_PLT32
:
1646 /* MPX PLT is supported only if elf_x86_64_arch_bed
1647 is used in 64-bit mode. */
1650 && (get_elf_x86_64_backend_data (abfd
)
1651 == &elf_x86_64_arch_bed
))
1653 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= TRUE
;
1655 /* Create the second PLT for Intel MPX support. */
1656 if (htab
->plt_bnd
== NULL
)
1658 unsigned int plt_bnd_align
;
1659 const struct elf_backend_data
*bed
;
1661 bed
= get_elf_backend_data (info
->output_bfd
);
1662 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1663 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1664 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1667 if (htab
->elf
.dynobj
== NULL
)
1668 htab
->elf
.dynobj
= abfd
;
1670 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1672 (bed
->dynamic_sec_flags
1677 if (htab
->plt_bnd
== NULL
1678 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1687 case R_X86_64_GOTPCREL
:
1688 case R_X86_64_GOTPCREL64
:
1689 if (htab
->elf
.dynobj
== NULL
)
1690 htab
->elf
.dynobj
= abfd
;
1691 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1696 /* It is referenced by a non-shared object. */
1698 h
->root
.non_ir_ref
= 1;
1701 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1702 symtab_hdr
, sym_hashes
,
1703 &r_type
, GOT_UNKNOWN
,
1704 rel
, rel_end
, h
, r_symndx
))
1709 case R_X86_64_TLSLD
:
1710 htab
->tls_ld_got
.refcount
+= 1;
1713 case R_X86_64_TPOFF32
:
1714 if (!info
->executable
&& ABI_64_P (abfd
))
1717 name
= h
->root
.root
.string
;
1719 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1721 (*_bfd_error_handler
)
1722 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1724 x86_64_elf_howto_table
[r_type
].name
, name
);
1725 bfd_set_error (bfd_error_bad_value
);
1730 case R_X86_64_GOTTPOFF
:
1731 if (!info
->executable
)
1732 info
->flags
|= DF_STATIC_TLS
;
1735 case R_X86_64_GOT32
:
1736 case R_X86_64_GOTPCREL
:
1737 case R_X86_64_TLSGD
:
1738 case R_X86_64_GOT64
:
1739 case R_X86_64_GOTPCREL64
:
1740 case R_X86_64_GOTPLT64
:
1741 case R_X86_64_GOTPC32_TLSDESC
:
1742 case R_X86_64_TLSDESC_CALL
:
1743 /* This symbol requires a global offset table entry. */
1745 int tls_type
, old_tls_type
;
1749 default: tls_type
= GOT_NORMAL
; break;
1750 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1751 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1752 case R_X86_64_GOTPC32_TLSDESC
:
1753 case R_X86_64_TLSDESC_CALL
:
1754 tls_type
= GOT_TLS_GDESC
; break;
1759 h
->got
.refcount
+= 1;
1760 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1764 bfd_signed_vma
*local_got_refcounts
;
1766 /* This is a global offset table entry for a local symbol. */
1767 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1768 if (local_got_refcounts
== NULL
)
1772 size
= symtab_hdr
->sh_info
;
1773 size
*= sizeof (bfd_signed_vma
)
1774 + sizeof (bfd_vma
) + sizeof (char);
1775 local_got_refcounts
= ((bfd_signed_vma
*)
1776 bfd_zalloc (abfd
, size
));
1777 if (local_got_refcounts
== NULL
)
1779 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1780 elf_x86_64_local_tlsdesc_gotent (abfd
)
1781 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1782 elf_x86_64_local_got_tls_type (abfd
)
1783 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1785 local_got_refcounts
[r_symndx
] += 1;
1787 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1790 /* If a TLS symbol is accessed using IE at least once,
1791 there is no point to use dynamic model for it. */
1792 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1793 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1794 || tls_type
!= GOT_TLS_IE
))
1796 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1797 tls_type
= old_tls_type
;
1798 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1799 && GOT_TLS_GD_ANY_P (tls_type
))
1800 tls_type
|= old_tls_type
;
1804 name
= h
->root
.root
.string
;
1806 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1808 (*_bfd_error_handler
)
1809 (_("%B: '%s' accessed both as normal and thread local symbol"),
1811 bfd_set_error (bfd_error_bad_value
);
1816 if (old_tls_type
!= tls_type
)
1819 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1821 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1826 case R_X86_64_GOTOFF64
:
1827 case R_X86_64_GOTPC32
:
1828 case R_X86_64_GOTPC64
:
1830 if (htab
->elf
.sgot
== NULL
)
1832 if (htab
->elf
.dynobj
== NULL
)
1833 htab
->elf
.dynobj
= abfd
;
1834 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1840 case R_X86_64_PLT32
:
1841 case R_X86_64_PLT32_BND
:
1842 /* This symbol requires a procedure linkage table entry. We
1843 actually build the entry in adjust_dynamic_symbol,
1844 because this might be a case of linking PIC code which is
1845 never referenced by a dynamic object, in which case we
1846 don't need to generate a procedure linkage table entry
1849 /* If this is a local symbol, we resolve it directly without
1850 creating a procedure linkage table entry. */
1855 h
->plt
.refcount
+= 1;
1858 case R_X86_64_PLTOFF64
:
1859 /* This tries to form the 'address' of a function relative
1860 to GOT. For global symbols we need a PLT entry. */
1864 h
->plt
.refcount
+= 1;
1868 case R_X86_64_SIZE32
:
1869 case R_X86_64_SIZE64
:
1874 if (!ABI_64_P (abfd
))
1879 /* Let's help debug shared library creation. These relocs
1880 cannot be used in shared libs. Don't error out for
1881 sections we don't care about, such as debug sections or
1882 non-constant sections. */
1884 && (sec
->flags
& SEC_ALLOC
) != 0
1885 && (sec
->flags
& SEC_READONLY
) != 0)
1888 name
= h
->root
.root
.string
;
1890 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1891 (*_bfd_error_handler
)
1892 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1893 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1894 bfd_set_error (bfd_error_bad_value
);
1902 case R_X86_64_PC32_BND
:
1906 if (h
!= NULL
&& info
->executable
)
1908 /* If this reloc is in a read-only section, we might
1909 need a copy reloc. We can't check reliably at this
1910 stage whether the section is read-only, as input
1911 sections have not yet been mapped to output sections.
1912 Tentatively set the flag for now, and correct in
1913 adjust_dynamic_symbol. */
1916 /* We may need a .plt entry if the function this reloc
1917 refers to is in a shared lib. */
1918 h
->plt
.refcount
+= 1;
1919 if (r_type
!= R_X86_64_PC32
1920 && r_type
!= R_X86_64_PC32_BND
1921 && r_type
!= R_X86_64_PC64
)
1922 h
->pointer_equality_needed
= 1;
1927 /* If we are creating a shared library, and this is a reloc
1928 against a global symbol, or a non PC relative reloc
1929 against a local symbol, then we need to copy the reloc
1930 into the shared library. However, if we are linking with
1931 -Bsymbolic, we do not need to copy a reloc against a
1932 global symbol which is defined in an object we are
1933 including in the link (i.e., DEF_REGULAR is set). At
1934 this point we have not seen all the input files, so it is
1935 possible that DEF_REGULAR is not set now but will be set
1936 later (it is never cleared). In case of a weak definition,
1937 DEF_REGULAR may be cleared later by a strong definition in
1938 a shared library. We account for that possibility below by
1939 storing information in the relocs_copied field of the hash
1940 table entry. A similar situation occurs when creating
1941 shared libraries and symbol visibility changes render the
1944 If on the other hand, we are creating an executable, we
1945 may need to keep relocations for symbols satisfied by a
1946 dynamic library if we manage to avoid copy relocs for the
1949 && (sec
->flags
& SEC_ALLOC
) != 0
1950 && (! IS_X86_64_PCREL_TYPE (r_type
)
1952 && (! SYMBOLIC_BIND (info
, h
)
1953 || h
->root
.type
== bfd_link_hash_defweak
1954 || !h
->def_regular
))))
1955 || (ELIMINATE_COPY_RELOCS
1957 && (sec
->flags
& SEC_ALLOC
) != 0
1959 && (h
->root
.type
== bfd_link_hash_defweak
1960 || !h
->def_regular
)))
1962 struct elf_dyn_relocs
*p
;
1963 struct elf_dyn_relocs
**head
;
1965 /* We must copy these reloc types into the output file.
1966 Create a reloc section in dynobj and make room for
1970 if (htab
->elf
.dynobj
== NULL
)
1971 htab
->elf
.dynobj
= abfd
;
1973 sreloc
= _bfd_elf_make_dynamic_reloc_section
1974 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1975 abfd
, /*rela?*/ TRUE
);
1981 /* If this is a global symbol, we count the number of
1982 relocations we need for this symbol. */
1985 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1989 /* Track dynamic relocs needed for local syms too.
1990 We really need local syms available to do this
1995 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2000 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2004 /* Beware of type punned pointers vs strict aliasing
2006 vpp
= &(elf_section_data (s
)->local_dynrel
);
2007 head
= (struct elf_dyn_relocs
**)vpp
;
2011 if (p
== NULL
|| p
->sec
!= sec
)
2013 bfd_size_type amt
= sizeof *p
;
2015 p
= ((struct elf_dyn_relocs
*)
2016 bfd_alloc (htab
->elf
.dynobj
, amt
));
2027 /* Count size relocation as PC-relative relocation. */
2028 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2033 /* This relocation describes the C++ object vtable hierarchy.
2034 Reconstruct it for later use during GC. */
2035 case R_X86_64_GNU_VTINHERIT
:
2036 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2040 /* This relocation describes which C++ vtable entries are actually
2041 used. Record for later use during GC. */
2042 case R_X86_64_GNU_VTENTRY
:
2043 BFD_ASSERT (h
!= NULL
);
2045 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2055 && h
->plt
.refcount
> 0
2056 && h
->got
.refcount
> 0
2057 && htab
->plt_got
== NULL
)
2059 /* Create the GOT procedure linkage table. */
2060 unsigned int plt_got_align
;
2061 const struct elf_backend_data
*bed
;
2063 bed
= get_elf_backend_data (info
->output_bfd
);
2064 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2065 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2066 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2069 if (htab
->elf
.dynobj
== NULL
)
2070 htab
->elf
.dynobj
= abfd
;
2072 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2074 (bed
->dynamic_sec_flags
2079 if (htab
->plt_got
== NULL
2080 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2090 /* Return the section that should be marked against GC for a given
2094 elf_x86_64_gc_mark_hook (asection
*sec
,
2095 struct bfd_link_info
*info
,
2096 Elf_Internal_Rela
*rel
,
2097 struct elf_link_hash_entry
*h
,
2098 Elf_Internal_Sym
*sym
)
2101 switch (ELF32_R_TYPE (rel
->r_info
))
2103 case R_X86_64_GNU_VTINHERIT
:
2104 case R_X86_64_GNU_VTENTRY
:
2108 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2111 /* Update the got entry reference counts for the section being removed. */
2114 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2116 const Elf_Internal_Rela
*relocs
)
2118 struct elf_x86_64_link_hash_table
*htab
;
2119 Elf_Internal_Shdr
*symtab_hdr
;
2120 struct elf_link_hash_entry
**sym_hashes
;
2121 bfd_signed_vma
*local_got_refcounts
;
2122 const Elf_Internal_Rela
*rel
, *relend
;
2124 if (info
->relocatable
)
2127 htab
= elf_x86_64_hash_table (info
);
2131 elf_section_data (sec
)->local_dynrel
= NULL
;
2133 symtab_hdr
= &elf_symtab_hdr (abfd
);
2134 sym_hashes
= elf_sym_hashes (abfd
);
2135 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2137 htab
= elf_x86_64_hash_table (info
);
2138 relend
= relocs
+ sec
->reloc_count
;
2139 for (rel
= relocs
; rel
< relend
; rel
++)
2141 unsigned long r_symndx
;
2142 unsigned int r_type
;
2143 struct elf_link_hash_entry
*h
= NULL
;
2145 r_symndx
= htab
->r_sym (rel
->r_info
);
2146 if (r_symndx
>= symtab_hdr
->sh_info
)
2148 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2149 while (h
->root
.type
== bfd_link_hash_indirect
2150 || h
->root
.type
== bfd_link_hash_warning
)
2151 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2155 /* A local symbol. */
2156 Elf_Internal_Sym
*isym
;
2158 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2161 /* Check relocation against local STT_GNU_IFUNC symbol. */
2163 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2165 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2173 struct elf_x86_64_link_hash_entry
*eh
;
2174 struct elf_dyn_relocs
**pp
;
2175 struct elf_dyn_relocs
*p
;
2177 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2179 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2182 /* Everything must go for SEC. */
2188 r_type
= ELF32_R_TYPE (rel
->r_info
);
2189 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2190 symtab_hdr
, sym_hashes
,
2191 &r_type
, GOT_UNKNOWN
,
2192 rel
, relend
, h
, r_symndx
))
2197 case R_X86_64_TLSLD
:
2198 if (htab
->tls_ld_got
.refcount
> 0)
2199 htab
->tls_ld_got
.refcount
-= 1;
2202 case R_X86_64_TLSGD
:
2203 case R_X86_64_GOTPC32_TLSDESC
:
2204 case R_X86_64_TLSDESC_CALL
:
2205 case R_X86_64_GOTTPOFF
:
2206 case R_X86_64_GOT32
:
2207 case R_X86_64_GOTPCREL
:
2208 case R_X86_64_GOT64
:
2209 case R_X86_64_GOTPCREL64
:
2210 case R_X86_64_GOTPLT64
:
2213 if (h
->got
.refcount
> 0)
2214 h
->got
.refcount
-= 1;
2215 if (h
->type
== STT_GNU_IFUNC
)
2217 if (h
->plt
.refcount
> 0)
2218 h
->plt
.refcount
-= 1;
2221 else if (local_got_refcounts
!= NULL
)
2223 if (local_got_refcounts
[r_symndx
] > 0)
2224 local_got_refcounts
[r_symndx
] -= 1;
2236 case R_X86_64_PC32_BND
:
2238 case R_X86_64_SIZE32
:
2239 case R_X86_64_SIZE64
:
2241 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2245 case R_X86_64_PLT32
:
2246 case R_X86_64_PLT32_BND
:
2247 case R_X86_64_PLTOFF64
:
2250 if (h
->plt
.refcount
> 0)
2251 h
->plt
.refcount
-= 1;
2263 /* Adjust a symbol defined by a dynamic object and referenced by a
2264 regular object. The current definition is in some section of the
2265 dynamic object, but we're not including those sections. We have to
2266 change the definition to something the rest of the link can
2270 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2271 struct elf_link_hash_entry
*h
)
2273 struct elf_x86_64_link_hash_table
*htab
;
2275 struct elf_x86_64_link_hash_entry
*eh
;
2276 struct elf_dyn_relocs
*p
;
2278 /* STT_GNU_IFUNC symbol must go through PLT. */
2279 if (h
->type
== STT_GNU_IFUNC
)
2281 /* All local STT_GNU_IFUNC references must be treate as local
2282 calls via local PLT. */
2284 && SYMBOL_CALLS_LOCAL (info
, h
))
2286 bfd_size_type pc_count
= 0, count
= 0;
2287 struct elf_dyn_relocs
**pp
;
2289 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2290 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2292 pc_count
+= p
->pc_count
;
2293 p
->count
-= p
->pc_count
;
2302 if (pc_count
|| count
)
2306 if (h
->plt
.refcount
<= 0)
2307 h
->plt
.refcount
= 1;
2309 h
->plt
.refcount
+= 1;
2313 if (h
->plt
.refcount
<= 0)
2315 h
->plt
.offset
= (bfd_vma
) -1;
2321 /* If this is a function, put it in the procedure linkage table. We
2322 will fill in the contents of the procedure linkage table later,
2323 when we know the address of the .got section. */
2324 if (h
->type
== STT_FUNC
2327 if (h
->plt
.refcount
<= 0
2328 || SYMBOL_CALLS_LOCAL (info
, h
)
2329 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2330 && h
->root
.type
== bfd_link_hash_undefweak
))
2332 /* This case can occur if we saw a PLT32 reloc in an input
2333 file, but the symbol was never referred to by a dynamic
2334 object, or if all references were garbage collected. In
2335 such a case, we don't actually need to build a procedure
2336 linkage table, and we can just do a PC32 reloc instead. */
2337 h
->plt
.offset
= (bfd_vma
) -1;
2344 /* It's possible that we incorrectly decided a .plt reloc was
2345 needed for an R_X86_64_PC32 reloc to a non-function sym in
2346 check_relocs. We can't decide accurately between function and
2347 non-function syms in check-relocs; Objects loaded later in
2348 the link may change h->type. So fix it now. */
2349 h
->plt
.offset
= (bfd_vma
) -1;
2351 /* If this is a weak symbol, and there is a real definition, the
2352 processor independent code will have arranged for us to see the
2353 real definition first, and we can just use the same value. */
2354 if (h
->u
.weakdef
!= NULL
)
2356 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2357 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2358 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2359 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2360 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2361 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2365 /* This is a reference to a symbol defined by a dynamic object which
2366 is not a function. */
2368 /* If we are creating a shared library, we must presume that the
2369 only references to the symbol are via the global offset table.
2370 For such cases we need not do anything here; the relocations will
2371 be handled correctly by relocate_section. */
2375 /* If there are no references to this symbol that do not use the
2376 GOT, we don't need to generate a copy reloc. */
2377 if (!h
->non_got_ref
)
2380 /* If -z nocopyreloc was given, we won't generate them either. */
2381 if (info
->nocopyreloc
)
2387 if (ELIMINATE_COPY_RELOCS
)
2389 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2390 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2392 s
= p
->sec
->output_section
;
2393 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2397 /* If we didn't find any dynamic relocs in read-only sections, then
2398 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2406 /* We must allocate the symbol in our .dynbss section, which will
2407 become part of the .bss section of the executable. There will be
2408 an entry for this symbol in the .dynsym section. The dynamic
2409 object will contain position independent code, so all references
2410 from the dynamic object to this symbol will go through the global
2411 offset table. The dynamic linker will use the .dynsym entry to
2412 determine the address it must put in the global offset table, so
2413 both the dynamic object and the regular object will refer to the
2414 same memory location for the variable. */
2416 htab
= elf_x86_64_hash_table (info
);
2420 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2421 to copy the initial value out of the dynamic object and into the
2422 runtime process image. */
2423 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2425 const struct elf_backend_data
*bed
;
2426 bed
= get_elf_backend_data (info
->output_bfd
);
2427 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2433 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2436 /* Allocate space in .plt, .got and associated reloc sections for
2440 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2442 struct bfd_link_info
*info
;
2443 struct elf_x86_64_link_hash_table
*htab
;
2444 struct elf_x86_64_link_hash_entry
*eh
;
2445 struct elf_dyn_relocs
*p
;
2446 const struct elf_backend_data
*bed
;
2447 unsigned int plt_entry_size
;
2449 if (h
->root
.type
== bfd_link_hash_indirect
)
2452 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2454 info
= (struct bfd_link_info
*) inf
;
2455 htab
= elf_x86_64_hash_table (info
);
2458 bed
= get_elf_backend_data (info
->output_bfd
);
2459 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2461 /* We can't use the GOT PLT if pointer equality is needed since
2462 finish_dynamic_symbol won't clear symbol value and the dynamic
2463 linker won't update the GOT slot. We will get into an infinite
2464 loop at run-time. */
2465 if (htab
->plt_got
!= NULL
2466 && h
->type
!= STT_GNU_IFUNC
2467 && !h
->pointer_equality_needed
2468 && h
->plt
.refcount
> 0
2469 && h
->got
.refcount
> 0)
2471 /* Don't use the regular PLT if there are both GOT and GOTPLT
2473 h
->plt
.offset
= (bfd_vma
) -1;
2475 /* Use the GOT PLT. */
2476 eh
->plt_got
.refcount
= 1;
2479 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2480 here if it is defined and referenced in a non-shared object. */
2481 if (h
->type
== STT_GNU_IFUNC
2484 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2490 asection
*s
= htab
->plt_bnd
;
2491 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2493 /* Use the .plt.bnd section if it is created. */
2494 eh
->plt_bnd
.offset
= s
->size
;
2496 /* Make room for this entry in the .plt.bnd section. */
2497 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2505 else if (htab
->elf
.dynamic_sections_created
2506 && (h
->plt
.refcount
> 0 || eh
->plt_got
.refcount
> 0))
2508 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
2510 /* Make sure this symbol is output as a dynamic symbol.
2511 Undefined weak syms won't yet be marked as dynamic. */
2512 if (h
->dynindx
== -1
2513 && !h
->forced_local
)
2515 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2520 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2522 asection
*s
= htab
->elf
.splt
;
2523 asection
*bnd_s
= htab
->plt_bnd
;
2524 asection
*got_s
= htab
->plt_got
;
2526 /* If this is the first .plt entry, make room for the special
2529 s
->size
= plt_entry_size
;
2532 eh
->plt_got
.offset
= got_s
->size
;
2535 h
->plt
.offset
= s
->size
;
2537 eh
->plt_bnd
.offset
= bnd_s
->size
;
2540 /* If this symbol is not defined in a regular file, and we are
2541 not generating a shared library, then set the symbol to this
2542 location in the .plt. This is required to make function
2543 pointers compare as equal between the normal executable and
2544 the shared library. */
2550 /* We need to make a call to the entry of the GOT PLT
2551 instead of regular PLT entry. */
2552 h
->root
.u
.def
.section
= got_s
;
2553 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2559 /* We need to make a call to the entry of the second
2560 PLT instead of regular PLT entry. */
2561 h
->root
.u
.def
.section
= bnd_s
;
2562 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2566 h
->root
.u
.def
.section
= s
;
2567 h
->root
.u
.def
.value
= h
->plt
.offset
;
2572 /* Make room for this entry. */
2574 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2577 s
->size
+= plt_entry_size
;
2579 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2581 /* We also need to make an entry in the .got.plt section,
2582 which will be placed in the .got section by the linker
2584 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2586 /* We also need to make an entry in the .rela.plt
2588 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2589 htab
->elf
.srelplt
->reloc_count
++;
2594 h
->plt
.offset
= (bfd_vma
) -1;
2600 h
->plt
.offset
= (bfd_vma
) -1;
2604 eh
->tlsdesc_got
= (bfd_vma
) -1;
2606 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2607 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2608 if (h
->got
.refcount
> 0
2611 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2613 h
->got
.offset
= (bfd_vma
) -1;
2615 else if (h
->got
.refcount
> 0)
2619 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2621 /* Make sure this symbol is output as a dynamic symbol.
2622 Undefined weak syms won't yet be marked as dynamic. */
2623 if (h
->dynindx
== -1
2624 && !h
->forced_local
)
2626 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2630 if (GOT_TLS_GDESC_P (tls_type
))
2632 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2633 - elf_x86_64_compute_jump_table_size (htab
);
2634 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2635 h
->got
.offset
= (bfd_vma
) -2;
2637 if (! GOT_TLS_GDESC_P (tls_type
)
2638 || GOT_TLS_GD_P (tls_type
))
2641 h
->got
.offset
= s
->size
;
2642 s
->size
+= GOT_ENTRY_SIZE
;
2643 if (GOT_TLS_GD_P (tls_type
))
2644 s
->size
+= GOT_ENTRY_SIZE
;
2646 dyn
= htab
->elf
.dynamic_sections_created
;
2647 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2649 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2650 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2651 || tls_type
== GOT_TLS_IE
)
2652 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2653 else if (GOT_TLS_GD_P (tls_type
))
2654 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2655 else if (! GOT_TLS_GDESC_P (tls_type
)
2656 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2657 || h
->root
.type
!= bfd_link_hash_undefweak
)
2659 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2660 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2661 if (GOT_TLS_GDESC_P (tls_type
))
2663 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2664 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2668 h
->got
.offset
= (bfd_vma
) -1;
2670 if (eh
->dyn_relocs
== NULL
)
2673 /* In the shared -Bsymbolic case, discard space allocated for
2674 dynamic pc-relative relocs against symbols which turn out to be
2675 defined in regular objects. For the normal shared case, discard
2676 space for pc-relative relocs that have become local due to symbol
2677 visibility changes. */
2681 /* Relocs that use pc_count are those that appear on a call
2682 insn, or certain REL relocs that can generated via assembly.
2683 We want calls to protected symbols to resolve directly to the
2684 function rather than going via the plt. If people want
2685 function pointer comparisons to work as expected then they
2686 should avoid writing weird assembly. */
2687 if (SYMBOL_CALLS_LOCAL (info
, h
))
2689 struct elf_dyn_relocs
**pp
;
2691 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2693 p
->count
-= p
->pc_count
;
2702 /* Also discard relocs on undefined weak syms with non-default
2704 if (eh
->dyn_relocs
!= NULL
2705 && h
->root
.type
== bfd_link_hash_undefweak
)
2707 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2708 eh
->dyn_relocs
= NULL
;
2710 /* Make sure undefined weak symbols are output as a dynamic
2712 else if (h
->dynindx
== -1
2713 && ! h
->forced_local
2714 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2719 else if (ELIMINATE_COPY_RELOCS
)
2721 /* For the non-shared case, discard space for relocs against
2722 symbols which turn out to need copy relocs or are not
2728 || (htab
->elf
.dynamic_sections_created
2729 && (h
->root
.type
== bfd_link_hash_undefweak
2730 || h
->root
.type
== bfd_link_hash_undefined
))))
2732 /* Make sure this symbol is output as a dynamic symbol.
2733 Undefined weak syms won't yet be marked as dynamic. */
2734 if (h
->dynindx
== -1
2735 && ! h
->forced_local
2736 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2739 /* If that succeeded, we know we'll be keeping all the
2741 if (h
->dynindx
!= -1)
2745 eh
->dyn_relocs
= NULL
;
2750 /* Finally, allocate space. */
2751 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2755 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2757 BFD_ASSERT (sreloc
!= NULL
);
2759 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2765 /* Allocate space in .plt, .got and associated reloc sections for
2766 local dynamic relocs. */
2769 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2771 struct elf_link_hash_entry
*h
2772 = (struct elf_link_hash_entry
*) *slot
;
2774 if (h
->type
!= STT_GNU_IFUNC
2778 || h
->root
.type
!= bfd_link_hash_defined
)
2781 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2784 /* Find any dynamic relocs that apply to read-only sections. */
2787 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2790 struct elf_x86_64_link_hash_entry
*eh
;
2791 struct elf_dyn_relocs
*p
;
2793 /* Skip local IFUNC symbols. */
2794 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2797 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2798 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2800 asection
*s
= p
->sec
->output_section
;
2802 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2804 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2806 info
->flags
|= DF_TEXTREL
;
2808 if (info
->warn_shared_textrel
&& info
->shared
)
2809 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2810 p
->sec
->owner
, h
->root
.root
.string
,
2813 /* Not an error, just cut short the traversal. */
2821 mov foo@GOTPCREL(%rip), %reg
2824 with the local symbol, foo. */
2827 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2828 struct bfd_link_info
*link_info
)
2830 Elf_Internal_Shdr
*symtab_hdr
;
2831 Elf_Internal_Rela
*internal_relocs
;
2832 Elf_Internal_Rela
*irel
, *irelend
;
2834 struct elf_x86_64_link_hash_table
*htab
;
2835 bfd_boolean changed_contents
;
2836 bfd_boolean changed_relocs
;
2837 bfd_signed_vma
*local_got_refcounts
;
2839 /* Don't even try to convert non-ELF outputs. */
2840 if (!is_elf_hash_table (link_info
->hash
))
2843 /* Nothing to do if there are no codes, no relocations or no output. */
2844 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2845 || sec
->reloc_count
== 0
2846 || bfd_is_abs_section (sec
->output_section
))
2849 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2851 /* Load the relocations for this section. */
2852 internal_relocs
= (_bfd_elf_link_read_relocs
2853 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2854 link_info
->keep_memory
));
2855 if (internal_relocs
== NULL
)
2858 htab
= elf_x86_64_hash_table (link_info
);
2859 changed_contents
= FALSE
;
2860 changed_relocs
= FALSE
;
2861 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2863 /* Get the section contents. */
2864 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2865 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2868 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2872 irelend
= internal_relocs
+ sec
->reloc_count
;
2873 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2875 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2876 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2878 struct elf_link_hash_entry
*h
;
2880 if (r_type
!= R_X86_64_GOTPCREL
)
2883 /* Get the symbol referred to by the reloc. */
2884 if (r_symndx
< symtab_hdr
->sh_info
)
2886 Elf_Internal_Sym
*isym
;
2888 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2891 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2892 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2893 && irel
->r_offset
>= 2
2894 && bfd_get_8 (input_bfd
,
2895 contents
+ irel
->r_offset
- 2) == 0x8b)
2897 bfd_put_8 (output_bfd
, 0x8d,
2898 contents
+ irel
->r_offset
- 2);
2899 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2900 if (local_got_refcounts
!= NULL
2901 && local_got_refcounts
[r_symndx
] > 0)
2902 local_got_refcounts
[r_symndx
] -= 1;
2903 changed_contents
= TRUE
;
2904 changed_relocs
= TRUE
;
2909 indx
= r_symndx
- symtab_hdr
->sh_info
;
2910 h
= elf_sym_hashes (abfd
)[indx
];
2911 BFD_ASSERT (h
!= NULL
);
2913 while (h
->root
.type
== bfd_link_hash_indirect
2914 || h
->root
.type
== bfd_link_hash_warning
)
2915 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2917 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2918 avoid optimizing _DYNAMIC since ld.so may use its link-time
2921 && h
->type
!= STT_GNU_IFUNC
2922 && h
!= htab
->elf
.hdynamic
2923 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2924 && irel
->r_offset
>= 2
2925 && bfd_get_8 (input_bfd
,
2926 contents
+ irel
->r_offset
- 2) == 0x8b)
2928 bfd_put_8 (output_bfd
, 0x8d,
2929 contents
+ irel
->r_offset
- 2);
2930 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2931 if (h
->got
.refcount
> 0)
2932 h
->got
.refcount
-= 1;
2933 changed_contents
= TRUE
;
2934 changed_relocs
= TRUE
;
2938 if (contents
!= NULL
2939 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2941 if (!changed_contents
&& !link_info
->keep_memory
)
2945 /* Cache the section contents for elf_link_input_bfd. */
2946 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2950 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2952 if (!changed_relocs
)
2953 free (internal_relocs
);
2955 elf_section_data (sec
)->relocs
= internal_relocs
;
2961 if (contents
!= NULL
2962 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2964 if (internal_relocs
!= NULL
2965 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2966 free (internal_relocs
);
2970 /* Set the sizes of the dynamic sections. */
2973 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2974 struct bfd_link_info
*info
)
2976 struct elf_x86_64_link_hash_table
*htab
;
2981 const struct elf_backend_data
*bed
;
2983 htab
= elf_x86_64_hash_table (info
);
2986 bed
= get_elf_backend_data (output_bfd
);
2988 dynobj
= htab
->elf
.dynobj
;
2992 if (htab
->elf
.dynamic_sections_created
)
2994 /* Set the contents of the .interp section to the interpreter. */
2995 if (info
->executable
)
2997 s
= bfd_get_linker_section (dynobj
, ".interp");
3000 s
->size
= htab
->dynamic_interpreter_size
;
3001 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3005 /* Set up .got offsets for local syms, and space for local dynamic
3007 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3009 bfd_signed_vma
*local_got
;
3010 bfd_signed_vma
*end_local_got
;
3011 char *local_tls_type
;
3012 bfd_vma
*local_tlsdesc_gotent
;
3013 bfd_size_type locsymcount
;
3014 Elf_Internal_Shdr
*symtab_hdr
;
3017 if (! is_x86_64_elf (ibfd
))
3020 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3022 struct elf_dyn_relocs
*p
;
3024 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
3027 for (p
= (struct elf_dyn_relocs
*)
3028 (elf_section_data (s
)->local_dynrel
);
3032 if (!bfd_is_abs_section (p
->sec
)
3033 && bfd_is_abs_section (p
->sec
->output_section
))
3035 /* Input section has been discarded, either because
3036 it is a copy of a linkonce section or due to
3037 linker script /DISCARD/, so we'll be discarding
3040 else if (p
->count
!= 0)
3042 srel
= elf_section_data (p
->sec
)->sreloc
;
3043 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3044 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3045 && (info
->flags
& DF_TEXTREL
) == 0)
3047 info
->flags
|= DF_TEXTREL
;
3048 if (info
->warn_shared_textrel
&& info
->shared
)
3049 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
3050 p
->sec
->owner
, p
->sec
);
3056 local_got
= elf_local_got_refcounts (ibfd
);
3060 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3061 locsymcount
= symtab_hdr
->sh_info
;
3062 end_local_got
= local_got
+ locsymcount
;
3063 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3064 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3066 srel
= htab
->elf
.srelgot
;
3067 for (; local_got
< end_local_got
;
3068 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3070 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3073 if (GOT_TLS_GDESC_P (*local_tls_type
))
3075 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3076 - elf_x86_64_compute_jump_table_size (htab
);
3077 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3078 *local_got
= (bfd_vma
) -2;
3080 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3081 || GOT_TLS_GD_P (*local_tls_type
))
3083 *local_got
= s
->size
;
3084 s
->size
+= GOT_ENTRY_SIZE
;
3085 if (GOT_TLS_GD_P (*local_tls_type
))
3086 s
->size
+= GOT_ENTRY_SIZE
;
3089 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3090 || *local_tls_type
== GOT_TLS_IE
)
3092 if (GOT_TLS_GDESC_P (*local_tls_type
))
3094 htab
->elf
.srelplt
->size
3095 += bed
->s
->sizeof_rela
;
3096 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3098 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3099 || GOT_TLS_GD_P (*local_tls_type
))
3100 srel
->size
+= bed
->s
->sizeof_rela
;
3104 *local_got
= (bfd_vma
) -1;
3108 if (htab
->tls_ld_got
.refcount
> 0)
3110 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3112 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3113 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3114 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3117 htab
->tls_ld_got
.offset
= -1;
3119 /* Allocate global sym .plt and .got entries, and space for global
3120 sym dynamic relocs. */
3121 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3124 /* Allocate .plt and .got entries, and space for local symbols. */
3125 htab_traverse (htab
->loc_hash_table
,
3126 elf_x86_64_allocate_local_dynrelocs
,
3129 /* For every jump slot reserved in the sgotplt, reloc_count is
3130 incremented. However, when we reserve space for TLS descriptors,
3131 it's not incremented, so in order to compute the space reserved
3132 for them, it suffices to multiply the reloc count by the jump
3135 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3136 so that R_X86_64_IRELATIVE entries come last. */
3137 if (htab
->elf
.srelplt
)
3139 htab
->sgotplt_jump_table_size
3140 = elf_x86_64_compute_jump_table_size (htab
);
3141 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3143 else if (htab
->elf
.irelplt
)
3144 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3146 if (htab
->tlsdesc_plt
)
3148 /* If we're not using lazy TLS relocations, don't generate the
3149 PLT and GOT entries they require. */
3150 if ((info
->flags
& DF_BIND_NOW
))
3151 htab
->tlsdesc_plt
= 0;
3154 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3155 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3156 /* Reserve room for the initial entry.
3157 FIXME: we could probably do away with it in this case. */
3158 if (htab
->elf
.splt
->size
== 0)
3159 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3160 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3161 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3165 if (htab
->elf
.sgotplt
)
3167 /* Don't allocate .got.plt section if there are no GOT nor PLT
3168 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3169 if ((htab
->elf
.hgot
== NULL
3170 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3171 && (htab
->elf
.sgotplt
->size
3172 == get_elf_backend_data (output_bfd
)->got_header_size
)
3173 && (htab
->elf
.splt
== NULL
3174 || htab
->elf
.splt
->size
== 0)
3175 && (htab
->elf
.sgot
== NULL
3176 || htab
->elf
.sgot
->size
== 0)
3177 && (htab
->elf
.iplt
== NULL
3178 || htab
->elf
.iplt
->size
== 0)
3179 && (htab
->elf
.igotplt
== NULL
3180 || htab
->elf
.igotplt
->size
== 0))
3181 htab
->elf
.sgotplt
->size
= 0;
3184 if (htab
->plt_eh_frame
!= NULL
3185 && htab
->elf
.splt
!= NULL
3186 && htab
->elf
.splt
->size
!= 0
3187 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3188 && _bfd_elf_eh_frame_present (info
))
3190 const struct elf_x86_64_backend_data
*arch_data
3191 = get_elf_x86_64_arch_data (bed
);
3192 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3195 /* We now have determined the sizes of the various dynamic sections.
3196 Allocate memory for them. */
3198 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3200 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3203 if (s
== htab
->elf
.splt
3204 || s
== htab
->elf
.sgot
3205 || s
== htab
->elf
.sgotplt
3206 || s
== htab
->elf
.iplt
3207 || s
== htab
->elf
.igotplt
3208 || s
== htab
->plt_bnd
3209 || s
== htab
->plt_got
3210 || s
== htab
->plt_eh_frame
3211 || s
== htab
->sdynbss
)
3213 /* Strip this section if we don't need it; see the
3216 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3218 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3221 /* We use the reloc_count field as a counter if we need
3222 to copy relocs into the output file. */
3223 if (s
!= htab
->elf
.srelplt
)
3228 /* It's not one of our sections, so don't allocate space. */
3234 /* If we don't need this section, strip it from the
3235 output file. This is mostly to handle .rela.bss and
3236 .rela.plt. We must create both sections in
3237 create_dynamic_sections, because they must be created
3238 before the linker maps input sections to output
3239 sections. The linker does that before
3240 adjust_dynamic_symbol is called, and it is that
3241 function which decides whether anything needs to go
3242 into these sections. */
3244 s
->flags
|= SEC_EXCLUDE
;
3248 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3251 /* Allocate memory for the section contents. We use bfd_zalloc
3252 here in case unused entries are not reclaimed before the
3253 section's contents are written out. This should not happen,
3254 but this way if it does, we get a R_X86_64_NONE reloc instead
3256 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3257 if (s
->contents
== NULL
)
3261 if (htab
->plt_eh_frame
!= NULL
3262 && htab
->plt_eh_frame
->contents
!= NULL
)
3264 const struct elf_x86_64_backend_data
*arch_data
3265 = get_elf_x86_64_arch_data (bed
);
3267 memcpy (htab
->plt_eh_frame
->contents
,
3268 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3269 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3270 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3273 if (htab
->elf
.dynamic_sections_created
)
3275 /* Add some entries to the .dynamic section. We fill in the
3276 values later, in elf_x86_64_finish_dynamic_sections, but we
3277 must add the entries now so that we get the correct size for
3278 the .dynamic section. The DT_DEBUG entry is filled in by the
3279 dynamic linker and used by the debugger. */
3280 #define add_dynamic_entry(TAG, VAL) \
3281 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3283 if (info
->executable
)
3285 if (!add_dynamic_entry (DT_DEBUG
, 0))
3289 if (htab
->elf
.splt
->size
!= 0)
3291 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3292 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3293 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3294 || !add_dynamic_entry (DT_JMPREL
, 0))
3297 if (htab
->tlsdesc_plt
3298 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3299 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3305 if (!add_dynamic_entry (DT_RELA
, 0)
3306 || !add_dynamic_entry (DT_RELASZ
, 0)
3307 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3310 /* If any dynamic relocs apply to a read-only section,
3311 then we need a DT_TEXTREL entry. */
3312 if ((info
->flags
& DF_TEXTREL
) == 0)
3313 elf_link_hash_traverse (&htab
->elf
,
3314 elf_x86_64_readonly_dynrelocs
,
3317 if ((info
->flags
& DF_TEXTREL
) != 0)
3319 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3324 #undef add_dynamic_entry
3330 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3331 struct bfd_link_info
*info
)
3333 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3337 struct elf_link_hash_entry
*tlsbase
;
3339 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3340 "_TLS_MODULE_BASE_",
3341 FALSE
, FALSE
, FALSE
);
3343 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3345 struct elf_x86_64_link_hash_table
*htab
;
3346 struct bfd_link_hash_entry
*bh
= NULL
;
3347 const struct elf_backend_data
*bed
3348 = get_elf_backend_data (output_bfd
);
3350 htab
= elf_x86_64_hash_table (info
);
3354 if (!(_bfd_generic_link_add_one_symbol
3355 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3356 tls_sec
, 0, NULL
, FALSE
,
3357 bed
->collect
, &bh
)))
3360 htab
->tls_module_base
= bh
;
3362 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3363 tlsbase
->def_regular
= 1;
3364 tlsbase
->other
= STV_HIDDEN
;
3365 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3372 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3373 executables. Rather than setting it to the beginning of the TLS
3374 section, we have to set it to the end. This function may be called
3375 multiple times, it is idempotent. */
3378 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3380 struct elf_x86_64_link_hash_table
*htab
;
3381 struct bfd_link_hash_entry
*base
;
3383 if (!info
->executable
)
3386 htab
= elf_x86_64_hash_table (info
);
3390 base
= htab
->tls_module_base
;
3394 base
->u
.def
.value
= htab
->elf
.tls_size
;
3397 /* Return the base VMA address which should be subtracted from real addresses
3398 when resolving @dtpoff relocation.
3399 This is PT_TLS segment p_vaddr. */
3402 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3404 /* If tls_sec is NULL, we should have signalled an error already. */
3405 if (elf_hash_table (info
)->tls_sec
== NULL
)
3407 return elf_hash_table (info
)->tls_sec
->vma
;
3410 /* Return the relocation value for @tpoff relocation
3411 if STT_TLS virtual address is ADDRESS. */
3414 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3416 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3417 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3418 bfd_vma static_tls_size
;
3420 /* If tls_segment is NULL, we should have signalled an error already. */
3421 if (htab
->tls_sec
== NULL
)
3424 /* Consider special static TLS alignment requirements. */
3425 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3426 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3429 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3433 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3435 /* Opcode Instruction
3438 0x0f 0x8x conditional jump */
3440 && (contents
[offset
- 1] == 0xe8
3441 || contents
[offset
- 1] == 0xe9))
3443 && contents
[offset
- 2] == 0x0f
3444 && (contents
[offset
- 1] & 0xf0) == 0x80));
3447 /* Relocate an x86_64 ELF section. */
3450 elf_x86_64_relocate_section (bfd
*output_bfd
,
3451 struct bfd_link_info
*info
,
3453 asection
*input_section
,
3455 Elf_Internal_Rela
*relocs
,
3456 Elf_Internal_Sym
*local_syms
,
3457 asection
**local_sections
)
3459 struct elf_x86_64_link_hash_table
*htab
;
3460 Elf_Internal_Shdr
*symtab_hdr
;
3461 struct elf_link_hash_entry
**sym_hashes
;
3462 bfd_vma
*local_got_offsets
;
3463 bfd_vma
*local_tlsdesc_gotents
;
3464 Elf_Internal_Rela
*rel
;
3465 Elf_Internal_Rela
*relend
;
3466 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3468 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3470 htab
= elf_x86_64_hash_table (info
);
3473 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3474 sym_hashes
= elf_sym_hashes (input_bfd
);
3475 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3476 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3478 elf_x86_64_set_tls_module_base (info
);
3481 relend
= relocs
+ input_section
->reloc_count
;
3482 for (; rel
< relend
; rel
++)
3484 unsigned int r_type
;
3485 reloc_howto_type
*howto
;
3486 unsigned long r_symndx
;
3487 struct elf_link_hash_entry
*h
;
3488 struct elf_x86_64_link_hash_entry
*eh
;
3489 Elf_Internal_Sym
*sym
;
3491 bfd_vma off
, offplt
, plt_offset
;
3493 bfd_boolean unresolved_reloc
;
3494 bfd_reloc_status_type r
;
3496 asection
*base_got
, *resolved_plt
;
3499 r_type
= ELF32_R_TYPE (rel
->r_info
);
3500 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3501 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3504 if (r_type
>= (int) R_X86_64_standard
)
3506 (*_bfd_error_handler
)
3507 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3508 input_bfd
, input_section
, r_type
);
3509 bfd_set_error (bfd_error_bad_value
);
3513 if (r_type
!= (int) R_X86_64_32
3514 || ABI_64_P (output_bfd
))
3515 howto
= x86_64_elf_howto_table
+ r_type
;
3517 howto
= (x86_64_elf_howto_table
3518 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3519 r_symndx
= htab
->r_sym (rel
->r_info
);
3523 unresolved_reloc
= FALSE
;
3524 if (r_symndx
< symtab_hdr
->sh_info
)
3526 sym
= local_syms
+ r_symndx
;
3527 sec
= local_sections
[r_symndx
];
3529 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3531 st_size
= sym
->st_size
;
3533 /* Relocate against local STT_GNU_IFUNC symbol. */
3534 if (!info
->relocatable
3535 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3537 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3542 /* Set STT_GNU_IFUNC symbol value. */
3543 h
->root
.u
.def
.value
= sym
->st_value
;
3544 h
->root
.u
.def
.section
= sec
;
3549 bfd_boolean warned ATTRIBUTE_UNUSED
;
3550 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3552 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3553 r_symndx
, symtab_hdr
, sym_hashes
,
3555 unresolved_reloc
, warned
, ignored
);
3559 if (sec
!= NULL
&& discarded_section (sec
))
3560 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3561 rel
, 1, relend
, howto
, 0, contents
);
3563 if (info
->relocatable
)
3566 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3568 if (r_type
== R_X86_64_64
)
3570 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3571 zero-extend it to 64bit if addend is zero. */
3572 r_type
= R_X86_64_32
;
3573 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3575 else if (r_type
== R_X86_64_SIZE64
)
3577 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3578 zero-extend it to 64bit if addend is zero. */
3579 r_type
= R_X86_64_SIZE32
;
3580 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3584 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3586 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3587 it here if it is defined in a non-shared object. */
3589 && h
->type
== STT_GNU_IFUNC
3595 if ((input_section
->flags
& SEC_ALLOC
) == 0
3596 || h
->plt
.offset
== (bfd_vma
) -1)
3599 /* STT_GNU_IFUNC symbol must go through PLT. */
3600 if (htab
->elf
.splt
!= NULL
)
3602 if (htab
->plt_bnd
!= NULL
)
3604 resolved_plt
= htab
->plt_bnd
;
3605 plt_offset
= eh
->plt_bnd
.offset
;
3609 resolved_plt
= htab
->elf
.splt
;
3610 plt_offset
= h
->plt
.offset
;
3615 resolved_plt
= htab
->elf
.iplt
;
3616 plt_offset
= h
->plt
.offset
;
3619 relocation
= (resolved_plt
->output_section
->vma
3620 + resolved_plt
->output_offset
+ plt_offset
);
3625 if (h
->root
.root
.string
)
3626 name
= h
->root
.root
.string
;
3628 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3630 (*_bfd_error_handler
)
3631 (_("%B: relocation %s against STT_GNU_IFUNC "
3632 "symbol `%s' isn't handled by %s"), input_bfd
,
3633 x86_64_elf_howto_table
[r_type
].name
,
3634 name
, __FUNCTION__
);
3635 bfd_set_error (bfd_error_bad_value
);
3644 if (ABI_64_P (output_bfd
))
3648 if (rel
->r_addend
!= 0)
3650 if (h
->root
.root
.string
)
3651 name
= h
->root
.root
.string
;
3653 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3655 (*_bfd_error_handler
)
3656 (_("%B: relocation %s against STT_GNU_IFUNC "
3657 "symbol `%s' has non-zero addend: %d"),
3658 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3659 name
, rel
->r_addend
);
3660 bfd_set_error (bfd_error_bad_value
);
3664 /* Generate dynamic relcoation only when there is a
3665 non-GOT reference in a shared object. */
3666 if (info
->shared
&& h
->non_got_ref
)
3668 Elf_Internal_Rela outrel
;
3671 /* Need a dynamic relocation to get the real function
3673 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3677 if (outrel
.r_offset
== (bfd_vma
) -1
3678 || outrel
.r_offset
== (bfd_vma
) -2)
3681 outrel
.r_offset
+= (input_section
->output_section
->vma
3682 + input_section
->output_offset
);
3684 if (h
->dynindx
== -1
3686 || info
->executable
)
3688 /* This symbol is resolved locally. */
3689 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3690 outrel
.r_addend
= (h
->root
.u
.def
.value
3691 + h
->root
.u
.def
.section
->output_section
->vma
3692 + h
->root
.u
.def
.section
->output_offset
);
3696 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3697 outrel
.r_addend
= 0;
3700 sreloc
= htab
->elf
.irelifunc
;
3701 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3703 /* If this reloc is against an external symbol, we
3704 do not want to fiddle with the addend. Otherwise,
3705 we need to include the symbol value so that it
3706 becomes an addend for the dynamic reloc. For an
3707 internal symbol, we have updated addend. */
3712 case R_X86_64_PC32_BND
:
3714 case R_X86_64_PLT32
:
3715 case R_X86_64_PLT32_BND
:
3718 case R_X86_64_GOTPCREL
:
3719 case R_X86_64_GOTPCREL64
:
3720 base_got
= htab
->elf
.sgot
;
3721 off
= h
->got
.offset
;
3723 if (base_got
== NULL
)
3726 if (off
== (bfd_vma
) -1)
3728 /* We can't use h->got.offset here to save state, or
3729 even just remember the offset, as finish_dynamic_symbol
3730 would use that as offset into .got. */
3732 if (htab
->elf
.splt
!= NULL
)
3734 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3735 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3736 base_got
= htab
->elf
.sgotplt
;
3740 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3741 off
= plt_index
* GOT_ENTRY_SIZE
;
3742 base_got
= htab
->elf
.igotplt
;
3745 if (h
->dynindx
== -1
3749 /* This references the local defitionion. We must
3750 initialize this entry in the global offset table.
3751 Since the offset must always be a multiple of 8,
3752 we use the least significant bit to record
3753 whether we have initialized it already.
3755 When doing a dynamic link, we create a .rela.got
3756 relocation entry to initialize the value. This
3757 is done in the finish_dynamic_symbol routine. */
3762 bfd_put_64 (output_bfd
, relocation
,
3763 base_got
->contents
+ off
);
3764 /* Note that this is harmless for the GOTPLT64
3765 case, as -1 | 1 still is -1. */
3771 relocation
= (base_got
->output_section
->vma
3772 + base_got
->output_offset
+ off
);
3778 /* When generating a shared object, the relocations handled here are
3779 copied into the output file to be resolved at run time. */
3782 case R_X86_64_GOT32
:
3783 case R_X86_64_GOT64
:
3784 /* Relocation is to the entry for this symbol in the global
3786 case R_X86_64_GOTPCREL
:
3787 case R_X86_64_GOTPCREL64
:
3788 /* Use global offset table entry as symbol value. */
3789 case R_X86_64_GOTPLT64
:
3790 /* This is obsolete and treated the the same as GOT64. */
3791 base_got
= htab
->elf
.sgot
;
3793 if (htab
->elf
.sgot
== NULL
)
3800 off
= h
->got
.offset
;
3802 && h
->plt
.offset
!= (bfd_vma
)-1
3803 && off
== (bfd_vma
)-1)
3805 /* We can't use h->got.offset here to save
3806 state, or even just remember the offset, as
3807 finish_dynamic_symbol would use that as offset into
3809 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3810 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3811 base_got
= htab
->elf
.sgotplt
;
3814 dyn
= htab
->elf
.dynamic_sections_created
;
3816 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3818 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3819 || (ELF_ST_VISIBILITY (h
->other
)
3820 && h
->root
.type
== bfd_link_hash_undefweak
))
3822 /* This is actually a static link, or it is a -Bsymbolic
3823 link and the symbol is defined locally, or the symbol
3824 was forced to be local because of a version file. We
3825 must initialize this entry in the global offset table.
3826 Since the offset must always be a multiple of 8, we
3827 use the least significant bit to record whether we
3828 have initialized it already.
3830 When doing a dynamic link, we create a .rela.got
3831 relocation entry to initialize the value. This is
3832 done in the finish_dynamic_symbol routine. */
3837 bfd_put_64 (output_bfd
, relocation
,
3838 base_got
->contents
+ off
);
3839 /* Note that this is harmless for the GOTPLT64 case,
3840 as -1 | 1 still is -1. */
3845 unresolved_reloc
= FALSE
;
3849 if (local_got_offsets
== NULL
)
3852 off
= local_got_offsets
[r_symndx
];
3854 /* The offset must always be a multiple of 8. We use
3855 the least significant bit to record whether we have
3856 already generated the necessary reloc. */
3861 bfd_put_64 (output_bfd
, relocation
,
3862 base_got
->contents
+ off
);
3867 Elf_Internal_Rela outrel
;
3869 /* We need to generate a R_X86_64_RELATIVE reloc
3870 for the dynamic linker. */
3871 s
= htab
->elf
.srelgot
;
3875 outrel
.r_offset
= (base_got
->output_section
->vma
3876 + base_got
->output_offset
3878 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3879 outrel
.r_addend
= relocation
;
3880 elf_append_rela (output_bfd
, s
, &outrel
);
3883 local_got_offsets
[r_symndx
] |= 1;
3887 if (off
>= (bfd_vma
) -2)
3890 relocation
= base_got
->output_section
->vma
3891 + base_got
->output_offset
+ off
;
3892 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3893 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3894 - htab
->elf
.sgotplt
->output_offset
;
3898 case R_X86_64_GOTOFF64
:
3899 /* Relocation is relative to the start of the global offset
3902 /* Check to make sure it isn't a protected function symbol
3903 for shared library since it may not be local when used
3904 as function address. */
3905 if (!info
->executable
3907 && !SYMBOLIC_BIND (info
, h
)
3909 && h
->type
== STT_FUNC
3910 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3912 (*_bfd_error_handler
)
3913 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3914 input_bfd
, h
->root
.root
.string
);
3915 bfd_set_error (bfd_error_bad_value
);
3919 /* Note that sgot is not involved in this
3920 calculation. We always want the start of .got.plt. If we
3921 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3922 permitted by the ABI, we might have to change this
3924 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3925 + htab
->elf
.sgotplt
->output_offset
;
3928 case R_X86_64_GOTPC32
:
3929 case R_X86_64_GOTPC64
:
3930 /* Use global offset table as symbol value. */
3931 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3932 + htab
->elf
.sgotplt
->output_offset
;
3933 unresolved_reloc
= FALSE
;
3936 case R_X86_64_PLTOFF64
:
3937 /* Relocation is PLT entry relative to GOT. For local
3938 symbols it's the symbol itself relative to GOT. */
3940 /* See PLT32 handling. */
3941 && h
->plt
.offset
!= (bfd_vma
) -1
3942 && htab
->elf
.splt
!= NULL
)
3944 if (htab
->plt_bnd
!= NULL
)
3946 resolved_plt
= htab
->plt_bnd
;
3947 plt_offset
= eh
->plt_bnd
.offset
;
3951 resolved_plt
= htab
->elf
.splt
;
3952 plt_offset
= h
->plt
.offset
;
3955 relocation
= (resolved_plt
->output_section
->vma
3956 + resolved_plt
->output_offset
3958 unresolved_reloc
= FALSE
;
3961 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3962 + htab
->elf
.sgotplt
->output_offset
;
3965 case R_X86_64_PLT32
:
3966 case R_X86_64_PLT32_BND
:
3967 /* Relocation is to the entry for this symbol in the
3968 procedure linkage table. */
3970 /* Resolve a PLT32 reloc against a local symbol directly,
3971 without using the procedure linkage table. */
3975 if ((h
->plt
.offset
== (bfd_vma
) -1
3976 && eh
->plt_got
.offset
== (bfd_vma
) -1)
3977 || htab
->elf
.splt
== NULL
)
3979 /* We didn't make a PLT entry for this symbol. This
3980 happens when statically linking PIC code, or when
3981 using -Bsymbolic. */
3985 if (h
->plt
.offset
!= (bfd_vma
) -1)
3987 if (htab
->plt_bnd
!= NULL
)
3989 resolved_plt
= htab
->plt_bnd
;
3990 plt_offset
= eh
->plt_bnd
.offset
;
3994 resolved_plt
= htab
->elf
.splt
;
3995 plt_offset
= h
->plt
.offset
;
4000 /* Use the GOT PLT. */
4001 resolved_plt
= htab
->plt_got
;
4002 plt_offset
= eh
->plt_got
.offset
;
4005 relocation
= (resolved_plt
->output_section
->vma
4006 + resolved_plt
->output_offset
4008 unresolved_reloc
= FALSE
;
4011 case R_X86_64_SIZE32
:
4012 case R_X86_64_SIZE64
:
4013 /* Set to symbol size. */
4014 relocation
= st_size
;
4020 case R_X86_64_PC32_BND
:
4022 && (input_section
->flags
& SEC_ALLOC
) != 0
4023 && (input_section
->flags
& SEC_READONLY
) != 0
4026 bfd_boolean fail
= FALSE
;
4028 = ((r_type
== R_X86_64_PC32
4029 || r_type
== R_X86_64_PC32_BND
)
4030 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4032 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4034 /* Symbol is referenced locally. Make sure it is
4035 defined locally or for a branch. */
4036 fail
= !h
->def_regular
&& !branch
;
4040 /* Symbol isn't referenced locally. We only allow
4041 branch to symbol with non-default visibility. */
4043 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4050 const char *pic
= "";
4052 switch (ELF_ST_VISIBILITY (h
->other
))
4055 v
= _("hidden symbol");
4058 v
= _("internal symbol");
4061 v
= _("protected symbol");
4065 pic
= _("; recompile with -fPIC");
4070 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4072 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4074 (*_bfd_error_handler
) (fmt
, input_bfd
,
4075 x86_64_elf_howto_table
[r_type
].name
,
4076 v
, h
->root
.root
.string
, pic
);
4077 bfd_set_error (bfd_error_bad_value
);
4088 /* FIXME: The ABI says the linker should make sure the value is
4089 the same when it's zeroextended to 64 bit. */
4092 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4097 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4098 || h
->root
.type
!= bfd_link_hash_undefweak
)
4099 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4100 && r_type
!= R_X86_64_SIZE32
4101 && r_type
!= R_X86_64_SIZE64
)
4102 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4103 || (ELIMINATE_COPY_RELOCS
4110 || h
->root
.type
== bfd_link_hash_undefweak
4111 || h
->root
.type
== bfd_link_hash_undefined
)))
4113 Elf_Internal_Rela outrel
;
4114 bfd_boolean skip
, relocate
;
4117 /* When generating a shared object, these relocations
4118 are copied into the output file to be resolved at run
4124 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4126 if (outrel
.r_offset
== (bfd_vma
) -1)
4128 else if (outrel
.r_offset
== (bfd_vma
) -2)
4129 skip
= TRUE
, relocate
= TRUE
;
4131 outrel
.r_offset
+= (input_section
->output_section
->vma
4132 + input_section
->output_offset
);
4135 memset (&outrel
, 0, sizeof outrel
);
4137 /* h->dynindx may be -1 if this symbol was marked to
4141 && (IS_X86_64_PCREL_TYPE (r_type
)
4143 || ! SYMBOLIC_BIND (info
, h
)
4144 || ! h
->def_regular
))
4146 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4147 outrel
.r_addend
= rel
->r_addend
;
4151 /* This symbol is local, or marked to become local. */
4152 if (r_type
== htab
->pointer_r_type
)
4155 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4156 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4158 else if (r_type
== R_X86_64_64
4159 && !ABI_64_P (output_bfd
))
4162 outrel
.r_info
= htab
->r_info (0,
4163 R_X86_64_RELATIVE64
);
4164 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4165 /* Check addend overflow. */
4166 if ((outrel
.r_addend
& 0x80000000)
4167 != (rel
->r_addend
& 0x80000000))
4170 int addend
= rel
->r_addend
;
4171 if (h
&& h
->root
.root
.string
)
4172 name
= h
->root
.root
.string
;
4174 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4177 (*_bfd_error_handler
)
4178 (_("%B: addend -0x%x in relocation %s against "
4179 "symbol `%s' at 0x%lx in section `%A' is "
4181 input_bfd
, input_section
, addend
,
4182 x86_64_elf_howto_table
[r_type
].name
,
4183 name
, (unsigned long) rel
->r_offset
);
4185 (*_bfd_error_handler
)
4186 (_("%B: addend 0x%x in relocation %s against "
4187 "symbol `%s' at 0x%lx in section `%A' is "
4189 input_bfd
, input_section
, addend
,
4190 x86_64_elf_howto_table
[r_type
].name
,
4191 name
, (unsigned long) rel
->r_offset
);
4192 bfd_set_error (bfd_error_bad_value
);
4200 if (bfd_is_abs_section (sec
))
4202 else if (sec
== NULL
|| sec
->owner
== NULL
)
4204 bfd_set_error (bfd_error_bad_value
);
4211 /* We are turning this relocation into one
4212 against a section symbol. It would be
4213 proper to subtract the symbol's value,
4214 osec->vma, from the emitted reloc addend,
4215 but ld.so expects buggy relocs. */
4216 osec
= sec
->output_section
;
4217 sindx
= elf_section_data (osec
)->dynindx
;
4220 asection
*oi
= htab
->elf
.text_index_section
;
4221 sindx
= elf_section_data (oi
)->dynindx
;
4223 BFD_ASSERT (sindx
!= 0);
4226 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4227 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4231 sreloc
= elf_section_data (input_section
)->sreloc
;
4233 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4235 r
= bfd_reloc_notsupported
;
4236 goto check_relocation_error
;
4239 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4241 /* If this reloc is against an external symbol, we do
4242 not want to fiddle with the addend. Otherwise, we
4243 need to include the symbol value so that it becomes
4244 an addend for the dynamic reloc. */
4251 case R_X86_64_TLSGD
:
4252 case R_X86_64_GOTPC32_TLSDESC
:
4253 case R_X86_64_TLSDESC_CALL
:
4254 case R_X86_64_GOTTPOFF
:
4255 tls_type
= GOT_UNKNOWN
;
4256 if (h
== NULL
&& local_got_offsets
)
4257 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4259 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4261 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4262 input_section
, contents
,
4263 symtab_hdr
, sym_hashes
,
4264 &r_type
, tls_type
, rel
,
4265 relend
, h
, r_symndx
))
4268 if (r_type
== R_X86_64_TPOFF32
)
4270 bfd_vma roff
= rel
->r_offset
;
4272 BFD_ASSERT (! unresolved_reloc
);
4274 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4276 /* GD->LE transition. For 64bit, change
4277 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4278 .word 0x6666; rex64; call __tls_get_addr
4281 leaq foo@tpoff(%rax), %rax
4283 leaq foo@tlsgd(%rip), %rdi
4284 .word 0x6666; rex64; call __tls_get_addr
4287 leaq foo@tpoff(%rax), %rax
4288 For largepic, change:
4289 leaq foo@tlsgd(%rip), %rdi
4290 movabsq $__tls_get_addr@pltoff, %rax
4295 leaq foo@tpoff(%rax), %rax
4296 nopw 0x0(%rax,%rax,1) */
4298 if (ABI_64_P (output_bfd
)
4299 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4301 memcpy (contents
+ roff
- 3,
4302 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4303 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4306 else if (ABI_64_P (output_bfd
))
4307 memcpy (contents
+ roff
- 4,
4308 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4311 memcpy (contents
+ roff
- 3,
4312 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4314 bfd_put_32 (output_bfd
,
4315 elf_x86_64_tpoff (info
, relocation
),
4316 contents
+ roff
+ 8 + largepic
);
4317 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4321 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4323 /* GDesc -> LE transition.
4324 It's originally something like:
4325 leaq x@tlsdesc(%rip), %rax
4328 movl $x@tpoff, %rax. */
4330 unsigned int val
, type
;
4332 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4333 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4334 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4335 contents
+ roff
- 3);
4336 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4337 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4338 contents
+ roff
- 1);
4339 bfd_put_32 (output_bfd
,
4340 elf_x86_64_tpoff (info
, relocation
),
4344 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4346 /* GDesc -> LE transition.
4351 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4352 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4355 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4357 /* IE->LE transition:
4358 For 64bit, originally it can be one of:
4359 movq foo@gottpoff(%rip), %reg
4360 addq foo@gottpoff(%rip), %reg
4363 leaq foo(%reg), %reg
4365 For 32bit, originally it can be one of:
4366 movq foo@gottpoff(%rip), %reg
4367 addl foo@gottpoff(%rip), %reg
4370 leal foo(%reg), %reg
4373 unsigned int val
, type
, reg
;
4376 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4379 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4380 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4386 bfd_put_8 (output_bfd
, 0x49,
4387 contents
+ roff
- 3);
4388 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4389 bfd_put_8 (output_bfd
, 0x41,
4390 contents
+ roff
- 3);
4391 bfd_put_8 (output_bfd
, 0xc7,
4392 contents
+ roff
- 2);
4393 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4394 contents
+ roff
- 1);
4398 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4401 bfd_put_8 (output_bfd
, 0x49,
4402 contents
+ roff
- 3);
4403 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4404 bfd_put_8 (output_bfd
, 0x41,
4405 contents
+ roff
- 3);
4406 bfd_put_8 (output_bfd
, 0x81,
4407 contents
+ roff
- 2);
4408 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4409 contents
+ roff
- 1);
4413 /* addq/addl -> leaq/leal */
4415 bfd_put_8 (output_bfd
, 0x4d,
4416 contents
+ roff
- 3);
4417 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4418 bfd_put_8 (output_bfd
, 0x45,
4419 contents
+ roff
- 3);
4420 bfd_put_8 (output_bfd
, 0x8d,
4421 contents
+ roff
- 2);
4422 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4423 contents
+ roff
- 1);
4425 bfd_put_32 (output_bfd
,
4426 elf_x86_64_tpoff (info
, relocation
),
4434 if (htab
->elf
.sgot
== NULL
)
4439 off
= h
->got
.offset
;
4440 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4444 if (local_got_offsets
== NULL
)
4447 off
= local_got_offsets
[r_symndx
];
4448 offplt
= local_tlsdesc_gotents
[r_symndx
];
4455 Elf_Internal_Rela outrel
;
4459 if (htab
->elf
.srelgot
== NULL
)
4462 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4464 if (GOT_TLS_GDESC_P (tls_type
))
4466 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4467 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4468 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4469 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4470 + htab
->elf
.sgotplt
->output_offset
4472 + htab
->sgotplt_jump_table_size
);
4473 sreloc
= htab
->elf
.srelplt
;
4475 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4477 outrel
.r_addend
= 0;
4478 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4481 sreloc
= htab
->elf
.srelgot
;
4483 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4484 + htab
->elf
.sgot
->output_offset
+ off
);
4486 if (GOT_TLS_GD_P (tls_type
))
4487 dr_type
= R_X86_64_DTPMOD64
;
4488 else if (GOT_TLS_GDESC_P (tls_type
))
4491 dr_type
= R_X86_64_TPOFF64
;
4493 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4494 outrel
.r_addend
= 0;
4495 if ((dr_type
== R_X86_64_TPOFF64
4496 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4497 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4498 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4500 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4502 if (GOT_TLS_GD_P (tls_type
))
4506 BFD_ASSERT (! unresolved_reloc
);
4507 bfd_put_64 (output_bfd
,
4508 relocation
- elf_x86_64_dtpoff_base (info
),
4509 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4513 bfd_put_64 (output_bfd
, 0,
4514 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4515 outrel
.r_info
= htab
->r_info (indx
,
4517 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4518 elf_append_rela (output_bfd
, sreloc
,
4527 local_got_offsets
[r_symndx
] |= 1;
4530 if (off
>= (bfd_vma
) -2
4531 && ! GOT_TLS_GDESC_P (tls_type
))
4533 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4535 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4536 || r_type
== R_X86_64_TLSDESC_CALL
)
4537 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4538 + htab
->elf
.sgotplt
->output_offset
4539 + offplt
+ htab
->sgotplt_jump_table_size
;
4541 relocation
= htab
->elf
.sgot
->output_section
->vma
4542 + htab
->elf
.sgot
->output_offset
+ off
;
4543 unresolved_reloc
= FALSE
;
4547 bfd_vma roff
= rel
->r_offset
;
4549 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4551 /* GD->IE transition. For 64bit, change
4552 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4553 .word 0x6666; rex64; call __tls_get_addr@plt
4556 addq foo@gottpoff(%rip), %rax
4558 leaq foo@tlsgd(%rip), %rdi
4559 .word 0x6666; rex64; call __tls_get_addr@plt
4562 addq foo@gottpoff(%rip), %rax
4563 For largepic, change:
4564 leaq foo@tlsgd(%rip), %rdi
4565 movabsq $__tls_get_addr@pltoff, %rax
4570 addq foo@gottpoff(%rax), %rax
4571 nopw 0x0(%rax,%rax,1) */
4573 if (ABI_64_P (output_bfd
)
4574 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4576 memcpy (contents
+ roff
- 3,
4577 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4578 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4581 else if (ABI_64_P (output_bfd
))
4582 memcpy (contents
+ roff
- 4,
4583 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4586 memcpy (contents
+ roff
- 3,
4587 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4590 relocation
= (htab
->elf
.sgot
->output_section
->vma
4591 + htab
->elf
.sgot
->output_offset
+ off
4594 - input_section
->output_section
->vma
4595 - input_section
->output_offset
4597 bfd_put_32 (output_bfd
, relocation
,
4598 contents
+ roff
+ 8 + largepic
);
4599 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4603 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4605 /* GDesc -> IE transition.
4606 It's originally something like:
4607 leaq x@tlsdesc(%rip), %rax
4610 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4612 /* Now modify the instruction as appropriate. To
4613 turn a leaq into a movq in the form we use it, it
4614 suffices to change the second byte from 0x8d to
4616 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4618 bfd_put_32 (output_bfd
,
4619 htab
->elf
.sgot
->output_section
->vma
4620 + htab
->elf
.sgot
->output_offset
+ off
4622 - input_section
->output_section
->vma
4623 - input_section
->output_offset
4628 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4630 /* GDesc -> IE transition.
4637 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4638 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4646 case R_X86_64_TLSLD
:
4647 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4648 input_section
, contents
,
4649 symtab_hdr
, sym_hashes
,
4650 &r_type
, GOT_UNKNOWN
,
4651 rel
, relend
, h
, r_symndx
))
4654 if (r_type
!= R_X86_64_TLSLD
)
4656 /* LD->LE transition:
4657 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4658 For 64bit, we change it into:
4659 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4660 For 32bit, we change it into:
4661 nopl 0x0(%rax); movl %fs:0, %eax.
4662 For largepic, change:
4663 leaq foo@tlsgd(%rip), %rdi
4664 movabsq $__tls_get_addr@pltoff, %rax
4668 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4671 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4672 if (ABI_64_P (output_bfd
)
4673 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4674 memcpy (contents
+ rel
->r_offset
- 3,
4675 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4676 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4677 else if (ABI_64_P (output_bfd
))
4678 memcpy (contents
+ rel
->r_offset
- 3,
4679 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4681 memcpy (contents
+ rel
->r_offset
- 3,
4682 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4683 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4688 if (htab
->elf
.sgot
== NULL
)
4691 off
= htab
->tls_ld_got
.offset
;
4696 Elf_Internal_Rela outrel
;
4698 if (htab
->elf
.srelgot
== NULL
)
4701 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4702 + htab
->elf
.sgot
->output_offset
+ off
);
4704 bfd_put_64 (output_bfd
, 0,
4705 htab
->elf
.sgot
->contents
+ off
);
4706 bfd_put_64 (output_bfd
, 0,
4707 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4708 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4709 outrel
.r_addend
= 0;
4710 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4712 htab
->tls_ld_got
.offset
|= 1;
4714 relocation
= htab
->elf
.sgot
->output_section
->vma
4715 + htab
->elf
.sgot
->output_offset
+ off
;
4716 unresolved_reloc
= FALSE
;
4719 case R_X86_64_DTPOFF32
:
4720 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4721 relocation
-= elf_x86_64_dtpoff_base (info
);
4723 relocation
= elf_x86_64_tpoff (info
, relocation
);
4726 case R_X86_64_TPOFF32
:
4727 case R_X86_64_TPOFF64
:
4728 BFD_ASSERT (info
->executable
);
4729 relocation
= elf_x86_64_tpoff (info
, relocation
);
4732 case R_X86_64_DTPOFF64
:
4733 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4734 relocation
-= elf_x86_64_dtpoff_base (info
);
4741 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4742 because such sections are not SEC_ALLOC and thus ld.so will
4743 not process them. */
4744 if (unresolved_reloc
4745 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4747 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4748 rel
->r_offset
) != (bfd_vma
) -1)
4750 (*_bfd_error_handler
)
4751 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4754 (long) rel
->r_offset
,
4756 h
->root
.root
.string
);
4761 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4762 contents
, rel
->r_offset
,
4763 relocation
, rel
->r_addend
);
4765 check_relocation_error
:
4766 if (r
!= bfd_reloc_ok
)
4771 name
= h
->root
.root
.string
;
4774 name
= bfd_elf_string_from_elf_section (input_bfd
,
4775 symtab_hdr
->sh_link
,
4780 name
= bfd_section_name (input_bfd
, sec
);
4783 if (r
== bfd_reloc_overflow
)
4785 if (! ((*info
->callbacks
->reloc_overflow
)
4786 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4787 (bfd_vma
) 0, input_bfd
, input_section
,
4793 (*_bfd_error_handler
)
4794 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4795 input_bfd
, input_section
,
4796 (long) rel
->r_offset
, name
, (int) r
);
4805 /* Finish up dynamic symbol handling. We set the contents of various
4806 dynamic sections here. */
4809 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4810 struct bfd_link_info
*info
,
4811 struct elf_link_hash_entry
*h
,
4812 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4814 struct elf_x86_64_link_hash_table
*htab
;
4815 const struct elf_x86_64_backend_data
*abed
;
4816 bfd_boolean use_plt_bnd
;
4817 struct elf_x86_64_link_hash_entry
*eh
;
4819 htab
= elf_x86_64_hash_table (info
);
4823 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4824 section only if there is .plt section. */
4825 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
4827 ? &elf_x86_64_bnd_arch_bed
4828 : get_elf_x86_64_backend_data (output_bfd
));
4830 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4832 if (h
->plt
.offset
!= (bfd_vma
) -1)
4835 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
4836 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
4837 Elf_Internal_Rela rela
;
4839 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4840 const struct elf_backend_data
*bed
;
4841 bfd_vma plt_got_pcrel_offset
;
4843 /* When building a static executable, use .iplt, .igot.plt and
4844 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4845 if (htab
->elf
.splt
!= NULL
)
4847 plt
= htab
->elf
.splt
;
4848 gotplt
= htab
->elf
.sgotplt
;
4849 relplt
= htab
->elf
.srelplt
;
4853 plt
= htab
->elf
.iplt
;
4854 gotplt
= htab
->elf
.igotplt
;
4855 relplt
= htab
->elf
.irelplt
;
4858 /* This symbol has an entry in the procedure linkage table. Set
4860 if ((h
->dynindx
== -1
4861 && !((h
->forced_local
|| info
->executable
)
4863 && h
->type
== STT_GNU_IFUNC
))
4869 /* Get the index in the procedure linkage table which
4870 corresponds to this symbol. This is the index of this symbol
4871 in all the symbols for which we are making plt entries. The
4872 first entry in the procedure linkage table is reserved.
4874 Get the offset into the .got table of the entry that
4875 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4876 bytes. The first three are reserved for the dynamic linker.
4878 For static executables, we don't reserve anything. */
4880 if (plt
== htab
->elf
.splt
)
4882 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4883 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4887 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4888 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4891 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
4892 plt_plt_offset
= abed
->plt_plt_offset
;
4893 plt_got_insn_size
= abed
->plt_got_insn_size
;
4894 plt_got_offset
= abed
->plt_got_offset
;
4897 /* Use the second PLT with BND relocations. */
4898 const bfd_byte
*plt_entry
, *plt2_entry
;
4900 if (eh
->has_bnd_reloc
)
4902 plt_entry
= elf_x86_64_bnd_plt_entry
;
4903 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
4907 plt_entry
= elf_x86_64_legacy_plt_entry
;
4908 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
4910 /* Subtract 1 since there is no BND prefix. */
4911 plt_plt_insn_end
-= 1;
4912 plt_plt_offset
-= 1;
4913 plt_got_insn_size
-= 1;
4914 plt_got_offset
-= 1;
4917 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
4918 == sizeof (elf_x86_64_legacy_plt_entry
));
4920 /* Fill in the entry in the procedure linkage table. */
4921 memcpy (plt
->contents
+ h
->plt
.offset
,
4922 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
4923 /* Fill in the entry in the second PLT. */
4924 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
4925 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
4927 resolved_plt
= htab
->plt_bnd
;
4928 plt_offset
= eh
->plt_bnd
.offset
;
4932 /* Fill in the entry in the procedure linkage table. */
4933 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4934 abed
->plt_entry_size
);
4937 plt_offset
= h
->plt
.offset
;
4940 /* Insert the relocation positions of the plt section. */
4942 /* Put offset the PC-relative instruction referring to the GOT entry,
4943 subtracting the size of that instruction. */
4944 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
4945 + gotplt
->output_offset
4947 - resolved_plt
->output_section
->vma
4948 - resolved_plt
->output_offset
4950 - plt_got_insn_size
);
4952 /* Check PC-relative offset overflow in PLT entry. */
4953 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
4954 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
4955 output_bfd
, h
->root
.root
.string
);
4957 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
4958 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
4960 /* Fill in the entry in the global offset table, initially this
4961 points to the second part of the PLT entry. */
4962 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4963 + plt
->output_offset
4964 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4965 gotplt
->contents
+ got_offset
);
4967 /* Fill in the entry in the .rela.plt section. */
4968 rela
.r_offset
= (gotplt
->output_section
->vma
4969 + gotplt
->output_offset
4971 if (h
->dynindx
== -1
4972 || ((info
->executable
4973 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4975 && h
->type
== STT_GNU_IFUNC
))
4977 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4978 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4979 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4980 rela
.r_addend
= (h
->root
.u
.def
.value
4981 + h
->root
.u
.def
.section
->output_section
->vma
4982 + h
->root
.u
.def
.section
->output_offset
);
4983 /* R_X86_64_IRELATIVE comes last. */
4984 plt_index
= htab
->next_irelative_index
--;
4988 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4990 plt_index
= htab
->next_jump_slot_index
++;
4993 /* Don't fill PLT entry for static executables. */
4994 if (plt
== htab
->elf
.splt
)
4996 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
4998 /* Put relocation index. */
4999 bfd_put_32 (output_bfd
, plt_index
,
5000 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
5002 /* Put offset for jmp .PLT0 and check for overflow. We don't
5003 check relocation index for overflow since branch displacement
5004 will overflow first. */
5005 if (plt0_offset
> 0x80000000)
5006 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5007 output_bfd
, h
->root
.root
.string
);
5008 bfd_put_32 (output_bfd
, - plt0_offset
,
5009 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5012 bed
= get_elf_backend_data (output_bfd
);
5013 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5014 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5016 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5018 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5019 asection
*plt
, *got
;
5020 bfd_boolean got_after_plt
;
5021 int32_t got_pcrel_offset
;
5022 const bfd_byte
*got_plt_entry
;
5024 /* Set the entry in the GOT procedure linkage table. */
5025 plt
= htab
->plt_got
;
5026 got
= htab
->elf
.sgot
;
5027 got_offset
= h
->got
.offset
;
5029 if (got_offset
== (bfd_vma
) -1
5030 || h
->type
== STT_GNU_IFUNC
5035 /* Use the second PLT entry template for the GOT PLT since they
5036 are the identical. */
5037 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5038 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5039 if (eh
->has_bnd_reloc
)
5040 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5043 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5045 /* Subtract 1 since there is no BND prefix. */
5046 plt_got_insn_size
-= 1;
5047 plt_got_offset
-= 1;
5050 /* Fill in the entry in the GOT procedure linkage table. */
5051 plt_offset
= eh
->plt_got
.offset
;
5052 memcpy (plt
->contents
+ plt_offset
,
5053 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5055 /* Put offset the PC-relative instruction referring to the GOT
5056 entry, subtracting the size of that instruction. */
5057 got_pcrel_offset
= (got
->output_section
->vma
5058 + got
->output_offset
5060 - plt
->output_section
->vma
5061 - plt
->output_offset
5063 - plt_got_insn_size
);
5065 /* Check PC-relative offset overflow in GOT PLT entry. */
5066 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5067 if ((got_after_plt
&& got_pcrel_offset
< 0)
5068 || (!got_after_plt
&& got_pcrel_offset
> 0))
5069 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5070 output_bfd
, h
->root
.root
.string
);
5072 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5073 plt
->contents
+ plt_offset
+ plt_got_offset
);
5077 && (h
->plt
.offset
!= (bfd_vma
) -1
5078 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5080 /* Mark the symbol as undefined, rather than as defined in
5081 the .plt section. Leave the value if there were any
5082 relocations where pointer equality matters (this is a clue
5083 for the dynamic linker, to make function pointer
5084 comparisons work between an application and shared
5085 library), otherwise set it to zero. If a function is only
5086 called from a binary, there is no need to slow down
5087 shared libraries because of that. */
5088 sym
->st_shndx
= SHN_UNDEF
;
5089 if (!h
->pointer_equality_needed
)
5093 if (h
->got
.offset
!= (bfd_vma
) -1
5094 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5095 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
5097 Elf_Internal_Rela rela
;
5099 /* This symbol has an entry in the global offset table. Set it
5101 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5104 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5105 + htab
->elf
.sgot
->output_offset
5106 + (h
->got
.offset
&~ (bfd_vma
) 1));
5108 /* If this is a static link, or it is a -Bsymbolic link and the
5109 symbol is defined locally or was forced to be local because
5110 of a version file, we just want to emit a RELATIVE reloc.
5111 The entry in the global offset table will already have been
5112 initialized in the relocate_section function. */
5114 && h
->type
== STT_GNU_IFUNC
)
5118 /* Generate R_X86_64_GLOB_DAT. */
5125 if (!h
->pointer_equality_needed
)
5128 /* For non-shared object, we can't use .got.plt, which
5129 contains the real function addres if we need pointer
5130 equality. We load the GOT entry with the PLT entry. */
5131 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5132 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5133 + plt
->output_offset
5135 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5139 else if (info
->shared
5140 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5142 if (!h
->def_regular
)
5144 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5145 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5146 rela
.r_addend
= (h
->root
.u
.def
.value
5147 + h
->root
.u
.def
.section
->output_section
->vma
5148 + h
->root
.u
.def
.section
->output_offset
);
5152 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5154 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5155 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5156 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5160 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5165 Elf_Internal_Rela rela
;
5167 /* This symbol needs a copy reloc. Set it up. */
5169 if (h
->dynindx
== -1
5170 || (h
->root
.type
!= bfd_link_hash_defined
5171 && h
->root
.type
!= bfd_link_hash_defweak
)
5172 || htab
->srelbss
== NULL
)
5175 rela
.r_offset
= (h
->root
.u
.def
.value
5176 + h
->root
.u
.def
.section
->output_section
->vma
5177 + h
->root
.u
.def
.section
->output_offset
);
5178 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5180 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5186 /* Finish up local dynamic symbol handling. We set the contents of
5187 various dynamic sections here. */
5190 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5192 struct elf_link_hash_entry
*h
5193 = (struct elf_link_hash_entry
*) *slot
;
5194 struct bfd_link_info
*info
5195 = (struct bfd_link_info
*) inf
;
5197 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5201 /* Used to decide how to sort relocs in an optimal manner for the
5202 dynamic linker, before writing them out. */
5204 static enum elf_reloc_type_class
5205 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5206 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5207 const Elf_Internal_Rela
*rela
)
5209 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5211 case R_X86_64_RELATIVE
:
5212 case R_X86_64_RELATIVE64
:
5213 return reloc_class_relative
;
5214 case R_X86_64_JUMP_SLOT
:
5215 return reloc_class_plt
;
5217 return reloc_class_copy
;
5219 return reloc_class_normal
;
5223 /* Finish up the dynamic sections. */
5226 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5227 struct bfd_link_info
*info
)
5229 struct elf_x86_64_link_hash_table
*htab
;
5232 const struct elf_x86_64_backend_data
*abed
;
5234 htab
= elf_x86_64_hash_table (info
);
5238 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5239 section only if there is .plt section. */
5240 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5241 ? &elf_x86_64_bnd_arch_bed
5242 : get_elf_x86_64_backend_data (output_bfd
));
5244 dynobj
= htab
->elf
.dynobj
;
5245 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5247 if (htab
->elf
.dynamic_sections_created
)
5249 bfd_byte
*dyncon
, *dynconend
;
5250 const struct elf_backend_data
*bed
;
5251 bfd_size_type sizeof_dyn
;
5253 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5256 bed
= get_elf_backend_data (dynobj
);
5257 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5258 dyncon
= sdyn
->contents
;
5259 dynconend
= sdyn
->contents
+ sdyn
->size
;
5260 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5262 Elf_Internal_Dyn dyn
;
5265 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5273 s
= htab
->elf
.sgotplt
;
5274 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5278 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5282 s
= htab
->elf
.srelplt
->output_section
;
5283 dyn
.d_un
.d_val
= s
->size
;
5287 /* The procedure linkage table relocs (DT_JMPREL) should
5288 not be included in the overall relocs (DT_RELA).
5289 Therefore, we override the DT_RELASZ entry here to
5290 make it not include the JMPREL relocs. Since the
5291 linker script arranges for .rela.plt to follow all
5292 other relocation sections, we don't have to worry
5293 about changing the DT_RELA entry. */
5294 if (htab
->elf
.srelplt
!= NULL
)
5296 s
= htab
->elf
.srelplt
->output_section
;
5297 dyn
.d_un
.d_val
-= s
->size
;
5301 case DT_TLSDESC_PLT
:
5303 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5304 + htab
->tlsdesc_plt
;
5307 case DT_TLSDESC_GOT
:
5309 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5310 + htab
->tlsdesc_got
;
5314 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5317 /* Fill in the special first entry in the procedure linkage table. */
5318 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5320 /* Fill in the first entry in the procedure linkage table. */
5321 memcpy (htab
->elf
.splt
->contents
,
5322 abed
->plt0_entry
, abed
->plt_entry_size
);
5323 /* Add offset for pushq GOT+8(%rip), since the instruction
5324 uses 6 bytes subtract this value. */
5325 bfd_put_32 (output_bfd
,
5326 (htab
->elf
.sgotplt
->output_section
->vma
5327 + htab
->elf
.sgotplt
->output_offset
5329 - htab
->elf
.splt
->output_section
->vma
5330 - htab
->elf
.splt
->output_offset
5332 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5333 /* Add offset for the PC-relative instruction accessing GOT+16,
5334 subtracting the offset to the end of that instruction. */
5335 bfd_put_32 (output_bfd
,
5336 (htab
->elf
.sgotplt
->output_section
->vma
5337 + htab
->elf
.sgotplt
->output_offset
5339 - htab
->elf
.splt
->output_section
->vma
5340 - htab
->elf
.splt
->output_offset
5341 - abed
->plt0_got2_insn_end
),
5342 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5344 elf_section_data (htab
->elf
.splt
->output_section
)
5345 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5347 if (htab
->tlsdesc_plt
)
5349 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5350 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5352 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5353 abed
->plt0_entry
, abed
->plt_entry_size
);
5355 /* Add offset for pushq GOT+8(%rip), since the
5356 instruction uses 6 bytes subtract this value. */
5357 bfd_put_32 (output_bfd
,
5358 (htab
->elf
.sgotplt
->output_section
->vma
5359 + htab
->elf
.sgotplt
->output_offset
5361 - htab
->elf
.splt
->output_section
->vma
5362 - htab
->elf
.splt
->output_offset
5365 htab
->elf
.splt
->contents
5366 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5367 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5368 where TGD stands for htab->tlsdesc_got, subtracting the offset
5369 to the end of that instruction. */
5370 bfd_put_32 (output_bfd
,
5371 (htab
->elf
.sgot
->output_section
->vma
5372 + htab
->elf
.sgot
->output_offset
5374 - htab
->elf
.splt
->output_section
->vma
5375 - htab
->elf
.splt
->output_offset
5377 - abed
->plt0_got2_insn_end
),
5378 htab
->elf
.splt
->contents
5379 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5384 if (htab
->plt_bnd
!= NULL
)
5385 elf_section_data (htab
->plt_bnd
->output_section
)
5386 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5388 if (htab
->elf
.sgotplt
)
5390 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5392 (*_bfd_error_handler
)
5393 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5397 /* Fill in the first three entries in the global offset table. */
5398 if (htab
->elf
.sgotplt
->size
> 0)
5400 /* Set the first entry in the global offset table to the address of
5401 the dynamic section. */
5403 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5405 bfd_put_64 (output_bfd
,
5406 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5407 htab
->elf
.sgotplt
->contents
);
5408 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5409 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5410 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5413 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5417 /* Adjust .eh_frame for .plt section. */
5418 if (htab
->plt_eh_frame
!= NULL
5419 && htab
->plt_eh_frame
->contents
!= NULL
)
5421 if (htab
->elf
.splt
!= NULL
5422 && htab
->elf
.splt
->size
!= 0
5423 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5424 && htab
->elf
.splt
->output_section
!= NULL
5425 && htab
->plt_eh_frame
->output_section
!= NULL
)
5427 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5428 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5429 + htab
->plt_eh_frame
->output_offset
5430 + PLT_FDE_START_OFFSET
;
5431 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5432 htab
->plt_eh_frame
->contents
5433 + PLT_FDE_START_OFFSET
);
5435 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5437 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5439 htab
->plt_eh_frame
->contents
))
5444 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5445 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5448 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5449 htab_traverse (htab
->loc_hash_table
,
5450 elf_x86_64_finish_local_dynamic_symbol
,
5456 /* Return address in section PLT for the Ith GOTPLT relocation, for
5457 relocation REL or (bfd_vma) -1 if it should not be included. */
5460 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
5464 const struct elf_x86_64_backend_data
*bed
;
5467 /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE. */
5468 if (rel
->howto
->type
!= R_X86_64_JUMP_SLOT
5469 && rel
->howto
->type
!= R_X86_64_IRELATIVE
)
5470 return (bfd_vma
) -1;
5473 bed
= get_elf_x86_64_backend_data (abfd
);
5474 plt_offset
= bed
->plt_entry_size
;
5476 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5477 return plt
->vma
+ (i
+ 1) * plt_offset
;
5479 while (plt_offset
< plt
->size
)
5481 bfd_vma reloc_index
;
5482 bfd_byte reloc_index_raw
[4];
5484 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5486 plt_offset
+ bed
->plt_reloc_offset
,
5487 sizeof (reloc_index_raw
)))
5488 return (bfd_vma
) -1;
5490 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5491 if (reloc_index
== i
)
5492 return plt
->vma
+ plt_offset
;
5493 plt_offset
+= bed
->plt_entry_size
;
5499 /* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
5500 PLT section, or (bfd_vma) -1 if it should not be included. */
5503 elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i
, const asection
*plt
)
5505 const struct elf_x86_64_backend_data
*bed
= &elf_x86_64_bnd_arch_bed
;
5506 bfd
*abfd
= plt
->owner
;
5507 bfd_vma plt_offset
= bed
->plt_entry_size
;
5509 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5510 return i
* sizeof (elf_x86_64_legacy_plt2_entry
);
5512 while (plt_offset
< plt
->size
)
5514 bfd_vma reloc_index
;
5515 bfd_byte reloc_index_raw
[4];
5517 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5519 plt_offset
+ bed
->plt_reloc_offset
,
5520 sizeof (reloc_index_raw
)))
5521 return (bfd_vma
) -1;
5523 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5524 if (reloc_index
== i
)
5526 /* This is the index in .plt section. */
5527 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5528 /* Return the offset in .plt.bnd section. */
5529 return (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
);
5531 plt_offset
+= bed
->plt_entry_size
;
5537 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5541 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5548 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5551 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5555 Elf_Internal_Shdr
*hdr
;
5557 asection
*plt
, *plt_push
;
5559 plt_push
= bfd_get_section_by_name (abfd
, ".plt");
5560 if (plt_push
== NULL
)
5563 plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5564 /* Use the generic ELF version if there is no .plt.bnd section. */
5566 return _bfd_elf_get_synthetic_symtab (abfd
, symcount
, syms
,
5567 dynsymcount
, dynsyms
, ret
);
5571 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
5574 if (dynsymcount
<= 0)
5577 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
5581 hdr
= &elf_section_data (relplt
)->this_hdr
;
5582 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
5583 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
5586 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5587 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5590 count
= relplt
->size
/ hdr
->sh_entsize
;
5591 size
= count
* sizeof (asymbol
);
5592 p
= relplt
->relocation
;
5593 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
5595 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
5597 size
+= sizeof ("+0x") - 1 + 8 + 8;
5600 s
= *ret
= (asymbol
*) bfd_malloc (size
);
5604 names
= (char *) (s
+ count
);
5605 p
= relplt
->relocation
;
5607 for (i
= 0; i
< count
; i
++, p
++)
5612 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5613 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5616 offset
= elf_x86_64_plt_sym_val_offset_plt_bnd (i
, plt_push
);
5618 *s
= **p
->sym_ptr_ptr
;
5619 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
5620 we are defining a symbol, ensure one of them is set. */
5621 if ((s
->flags
& BSF_LOCAL
) == 0)
5622 s
->flags
|= BSF_GLOBAL
;
5623 s
->flags
|= BSF_SYNTHETIC
;
5628 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
5629 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
5635 memcpy (names
, "+0x", sizeof ("+0x") - 1);
5636 names
+= sizeof ("+0x") - 1;
5637 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
5638 for (a
= buf
; *a
== '0'; ++a
)
5641 memcpy (names
, a
, len
);
5644 memcpy (names
, "@plt", sizeof ("@plt"));
5645 names
+= sizeof ("@plt");
5652 /* Handle an x86-64 specific section when reading an object file. This
5653 is called when elfcode.h finds a section with an unknown type. */
5656 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5657 const char *name
, int shindex
)
5659 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5662 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5668 /* Hook called by the linker routine which adds symbols from an object
5669 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5673 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5674 struct bfd_link_info
*info
,
5675 Elf_Internal_Sym
*sym
,
5676 const char **namep ATTRIBUTE_UNUSED
,
5677 flagword
*flagsp ATTRIBUTE_UNUSED
,
5683 switch (sym
->st_shndx
)
5685 case SHN_X86_64_LCOMMON
:
5686 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5689 lcomm
= bfd_make_section_with_flags (abfd
,
5693 | SEC_LINKER_CREATED
));
5696 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5699 *valp
= sym
->st_size
;
5703 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5704 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
5705 && (abfd
->flags
& DYNAMIC
) == 0
5706 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5707 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5713 /* Given a BFD section, try to locate the corresponding ELF section
5717 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5718 asection
*sec
, int *index_return
)
5720 if (sec
== &_bfd_elf_large_com_section
)
5722 *index_return
= SHN_X86_64_LCOMMON
;
5728 /* Process a symbol. */
5731 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5734 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5736 switch (elfsym
->internal_elf_sym
.st_shndx
)
5738 case SHN_X86_64_LCOMMON
:
5739 asym
->section
= &_bfd_elf_large_com_section
;
5740 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5741 /* Common symbol doesn't set BSF_GLOBAL. */
5742 asym
->flags
&= ~BSF_GLOBAL
;
5748 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5750 return (sym
->st_shndx
== SHN_COMMON
5751 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5755 elf_x86_64_common_section_index (asection
*sec
)
5757 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5760 return SHN_X86_64_LCOMMON
;
5764 elf_x86_64_common_section (asection
*sec
)
5766 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5767 return bfd_com_section_ptr
;
5769 return &_bfd_elf_large_com_section
;
5773 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5774 const Elf_Internal_Sym
*sym
,
5779 const asection
*oldsec
)
5781 /* A normal common symbol and a large common symbol result in a
5782 normal common symbol. We turn the large common symbol into a
5785 && h
->root
.type
== bfd_link_hash_common
5787 && bfd_is_com_section (*psec
)
5790 if (sym
->st_shndx
== SHN_COMMON
5791 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5793 h
->root
.u
.c
.p
->section
5794 = bfd_make_section_old_way (oldbfd
, "COMMON");
5795 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5797 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5798 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5799 *psec
= bfd_com_section_ptr
;
5806 elf_x86_64_additional_program_headers (bfd
*abfd
,
5807 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5812 /* Check to see if we need a large readonly segment. */
5813 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5814 if (s
&& (s
->flags
& SEC_LOAD
))
5817 /* Check to see if we need a large data segment. Since .lbss sections
5818 is placed right after the .bss section, there should be no need for
5819 a large data segment just because of .lbss. */
5820 s
= bfd_get_section_by_name (abfd
, ".ldata");
5821 if (s
&& (s
->flags
& SEC_LOAD
))
5827 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5830 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5832 if (h
->plt
.offset
!= (bfd_vma
) -1
5834 && !h
->pointer_equality_needed
)
5837 return _bfd_elf_hash_symbol (h
);
5840 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5843 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5844 const bfd_target
*output
)
5846 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5847 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5848 && _bfd_elf_relocs_compatible (input
, output
));
5851 static const struct bfd_elf_special_section
5852 elf_x86_64_special_sections
[]=
5854 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5855 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5856 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5857 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5858 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5859 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5860 { NULL
, 0, 0, 0, 0 }
5863 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5864 #define TARGET_LITTLE_NAME "elf64-x86-64"
5865 #define ELF_ARCH bfd_arch_i386
5866 #define ELF_TARGET_ID X86_64_ELF_DATA
5867 #define ELF_MACHINE_CODE EM_X86_64
5868 #define ELF_MAXPAGESIZE 0x200000
5869 #define ELF_MINPAGESIZE 0x1000
5870 #define ELF_COMMONPAGESIZE 0x1000
5872 #define elf_backend_can_gc_sections 1
5873 #define elf_backend_can_refcount 1
5874 #define elf_backend_want_got_plt 1
5875 #define elf_backend_plt_readonly 1
5876 #define elf_backend_want_plt_sym 0
5877 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5878 #define elf_backend_rela_normal 1
5879 #define elf_backend_plt_alignment 4
5881 #define elf_info_to_howto elf_x86_64_info_to_howto
5883 #define bfd_elf64_bfd_link_hash_table_create \
5884 elf_x86_64_link_hash_table_create
5885 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5886 #define bfd_elf64_bfd_reloc_name_lookup \
5887 elf_x86_64_reloc_name_lookup
5889 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5890 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5891 #define elf_backend_check_relocs elf_x86_64_check_relocs
5892 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5893 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5894 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5895 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5896 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5897 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5898 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5899 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5901 #define elf_backend_write_core_note elf_x86_64_write_core_note
5903 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5904 #define elf_backend_relocate_section elf_x86_64_relocate_section
5905 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5906 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5907 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5908 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5909 #define elf_backend_object_p elf64_x86_64_elf_object_p
5910 #define bfd_elf64_mkobject elf_x86_64_mkobject
5911 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5913 #define elf_backend_section_from_shdr \
5914 elf_x86_64_section_from_shdr
5916 #define elf_backend_section_from_bfd_section \
5917 elf_x86_64_elf_section_from_bfd_section
5918 #define elf_backend_add_symbol_hook \
5919 elf_x86_64_add_symbol_hook
5920 #define elf_backend_symbol_processing \
5921 elf_x86_64_symbol_processing
5922 #define elf_backend_common_section_index \
5923 elf_x86_64_common_section_index
5924 #define elf_backend_common_section \
5925 elf_x86_64_common_section
5926 #define elf_backend_common_definition \
5927 elf_x86_64_common_definition
5928 #define elf_backend_merge_symbol \
5929 elf_x86_64_merge_symbol
5930 #define elf_backend_special_sections \
5931 elf_x86_64_special_sections
5932 #define elf_backend_additional_program_headers \
5933 elf_x86_64_additional_program_headers
5934 #define elf_backend_hash_symbol \
5935 elf_x86_64_hash_symbol
5937 #include "elf64-target.h"
5939 /* FreeBSD support. */
5941 #undef TARGET_LITTLE_SYM
5942 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5943 #undef TARGET_LITTLE_NAME
5944 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5947 #define ELF_OSABI ELFOSABI_FREEBSD
5950 #define elf64_bed elf64_x86_64_fbsd_bed
5952 #include "elf64-target.h"
5954 /* Solaris 2 support. */
5956 #undef TARGET_LITTLE_SYM
5957 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5958 #undef TARGET_LITTLE_NAME
5959 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5961 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5962 objects won't be recognized. */
5966 #define elf64_bed elf64_x86_64_sol2_bed
5968 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5970 #undef elf_backend_static_tls_alignment
5971 #define elf_backend_static_tls_alignment 16
5973 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5975 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5977 #undef elf_backend_want_plt_sym
5978 #define elf_backend_want_plt_sym 1
5980 #include "elf64-target.h"
5982 #undef bfd_elf64_get_synthetic_symtab
5984 /* Native Client support. */
5987 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
5989 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5990 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
5994 #undef TARGET_LITTLE_SYM
5995 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5996 #undef TARGET_LITTLE_NAME
5997 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5999 #define elf64_bed elf64_x86_64_nacl_bed
6001 #undef ELF_MAXPAGESIZE
6002 #undef ELF_MINPAGESIZE
6003 #undef ELF_COMMONPAGESIZE
6004 #define ELF_MAXPAGESIZE 0x10000
6005 #define ELF_MINPAGESIZE 0x10000
6006 #define ELF_COMMONPAGESIZE 0x10000
6008 /* Restore defaults. */
6010 #undef elf_backend_static_tls_alignment
6011 #undef elf_backend_want_plt_sym
6012 #define elf_backend_want_plt_sym 0
6014 /* NaCl uses substantially different PLT entries for the same effects. */
6016 #undef elf_backend_plt_alignment
6017 #define elf_backend_plt_alignment 5
6018 #define NACL_PLT_ENTRY_SIZE 64
6019 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6021 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6023 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6024 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6025 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6026 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6027 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6029 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6030 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6032 /* 32 bytes of nop to pad out to the standard size. */
6033 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6034 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6035 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6036 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6037 0x66, /* excess data32 prefix */
6041 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6043 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6044 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6045 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6046 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6048 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6049 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6050 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6052 /* Lazy GOT entries point here (32-byte aligned). */
6053 0x68, /* pushq immediate */
6054 0, 0, 0, 0, /* replaced with index into relocation table. */
6055 0xe9, /* jmp relative */
6056 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6058 /* 22 bytes of nop to pad out to the standard size. */
6059 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6060 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6061 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6064 /* .eh_frame covering the .plt section. */
6066 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6068 #if (PLT_CIE_LENGTH != 20 \
6069 || PLT_FDE_LENGTH != 36 \
6070 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6071 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6072 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6074 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6075 0, 0, 0, 0, /* CIE ID */
6076 1, /* CIE version */
6077 'z', 'R', 0, /* Augmentation string */
6078 1, /* Code alignment factor */
6079 0x78, /* Data alignment factor */
6080 16, /* Return address column */
6081 1, /* Augmentation size */
6082 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6083 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6084 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6085 DW_CFA_nop
, DW_CFA_nop
,
6087 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6088 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6089 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6090 0, 0, 0, 0, /* .plt size goes here */
6091 0, /* Augmentation size */
6092 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6093 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6094 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6095 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6096 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6097 13, /* Block length */
6098 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6099 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6100 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6101 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6102 DW_CFA_nop
, DW_CFA_nop
6105 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6107 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6108 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6109 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6110 2, /* plt0_got1_offset */
6111 9, /* plt0_got2_offset */
6112 13, /* plt0_got2_insn_end */
6113 3, /* plt_got_offset */
6114 33, /* plt_reloc_offset */
6115 38, /* plt_plt_offset */
6116 7, /* plt_got_insn_size */
6117 42, /* plt_plt_insn_end */
6118 32, /* plt_lazy_offset */
6119 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6120 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6123 #undef elf_backend_arch_data
6124 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6126 #undef elf_backend_object_p
6127 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6128 #undef elf_backend_modify_segment_map
6129 #define elf_backend_modify_segment_map nacl_modify_segment_map
6130 #undef elf_backend_modify_program_headers
6131 #define elf_backend_modify_program_headers nacl_modify_program_headers
6132 #undef elf_backend_final_write_processing
6133 #define elf_backend_final_write_processing nacl_final_write_processing
6135 #include "elf64-target.h"
6137 /* Native Client x32 support. */
6140 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6142 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6143 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6147 #undef TARGET_LITTLE_SYM
6148 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6149 #undef TARGET_LITTLE_NAME
6150 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6152 #define elf32_bed elf32_x86_64_nacl_bed
6154 #define bfd_elf32_bfd_link_hash_table_create \
6155 elf_x86_64_link_hash_table_create
6156 #define bfd_elf32_bfd_reloc_type_lookup \
6157 elf_x86_64_reloc_type_lookup
6158 #define bfd_elf32_bfd_reloc_name_lookup \
6159 elf_x86_64_reloc_name_lookup
6160 #define bfd_elf32_mkobject \
6163 #undef elf_backend_object_p
6164 #define elf_backend_object_p \
6165 elf32_x86_64_nacl_elf_object_p
6167 #undef elf_backend_bfd_from_remote_memory
6168 #define elf_backend_bfd_from_remote_memory \
6169 _bfd_elf32_bfd_from_remote_memory
6171 #undef elf_backend_size_info
6172 #define elf_backend_size_info \
6173 _bfd_elf32_size_info
6175 #include "elf32-target.h"
6177 /* Restore defaults. */
6178 #undef elf_backend_object_p
6179 #define elf_backend_object_p elf64_x86_64_elf_object_p
6180 #undef elf_backend_bfd_from_remote_memory
6181 #undef elf_backend_size_info
6182 #undef elf_backend_modify_segment_map
6183 #undef elf_backend_modify_program_headers
6184 #undef elf_backend_final_write_processing
6186 /* Intel L1OM support. */
6189 elf64_l1om_elf_object_p (bfd
*abfd
)
6191 /* Set the right machine number for an L1OM elf64 file. */
6192 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6196 #undef TARGET_LITTLE_SYM
6197 #define TARGET_LITTLE_SYM l1om_elf64_vec
6198 #undef TARGET_LITTLE_NAME
6199 #define TARGET_LITTLE_NAME "elf64-l1om"
6201 #define ELF_ARCH bfd_arch_l1om
6203 #undef ELF_MACHINE_CODE
6204 #define ELF_MACHINE_CODE EM_L1OM
6209 #define elf64_bed elf64_l1om_bed
6211 #undef elf_backend_object_p
6212 #define elf_backend_object_p elf64_l1om_elf_object_p
6214 /* Restore defaults. */
6215 #undef ELF_MAXPAGESIZE
6216 #undef ELF_MINPAGESIZE
6217 #undef ELF_COMMONPAGESIZE
6218 #define ELF_MAXPAGESIZE 0x200000
6219 #define ELF_MINPAGESIZE 0x1000
6220 #define ELF_COMMONPAGESIZE 0x1000
6221 #undef elf_backend_plt_alignment
6222 #define elf_backend_plt_alignment 4
6223 #undef elf_backend_arch_data
6224 #define elf_backend_arch_data &elf_x86_64_arch_bed
6226 #include "elf64-target.h"
6228 /* FreeBSD L1OM support. */
6230 #undef TARGET_LITTLE_SYM
6231 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6232 #undef TARGET_LITTLE_NAME
6233 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6236 #define ELF_OSABI ELFOSABI_FREEBSD
6239 #define elf64_bed elf64_l1om_fbsd_bed
6241 #include "elf64-target.h"
6243 /* Intel K1OM support. */
6246 elf64_k1om_elf_object_p (bfd
*abfd
)
6248 /* Set the right machine number for an K1OM elf64 file. */
6249 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6253 #undef TARGET_LITTLE_SYM
6254 #define TARGET_LITTLE_SYM k1om_elf64_vec
6255 #undef TARGET_LITTLE_NAME
6256 #define TARGET_LITTLE_NAME "elf64-k1om"
6258 #define ELF_ARCH bfd_arch_k1om
6260 #undef ELF_MACHINE_CODE
6261 #define ELF_MACHINE_CODE EM_K1OM
6266 #define elf64_bed elf64_k1om_bed
6268 #undef elf_backend_object_p
6269 #define elf_backend_object_p elf64_k1om_elf_object_p
6271 #undef elf_backend_static_tls_alignment
6273 #undef elf_backend_want_plt_sym
6274 #define elf_backend_want_plt_sym 0
6276 #include "elf64-target.h"
6278 /* FreeBSD K1OM support. */
6280 #undef TARGET_LITTLE_SYM
6281 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6282 #undef TARGET_LITTLE_NAME
6283 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6286 #define ELF_OSABI ELFOSABI_FREEBSD
6289 #define elf64_bed elf64_k1om_fbsd_bed
6291 #include "elf64-target.h"
6293 /* 32bit x86-64 support. */
6295 #undef TARGET_LITTLE_SYM
6296 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6297 #undef TARGET_LITTLE_NAME
6298 #define TARGET_LITTLE_NAME "elf32-x86-64"
6302 #define ELF_ARCH bfd_arch_i386
6304 #undef ELF_MACHINE_CODE
6305 #define ELF_MACHINE_CODE EM_X86_64
6309 #undef elf_backend_object_p
6310 #define elf_backend_object_p \
6311 elf32_x86_64_elf_object_p
6313 #undef elf_backend_bfd_from_remote_memory
6314 #define elf_backend_bfd_from_remote_memory \
6315 _bfd_elf32_bfd_from_remote_memory
6317 #undef elf_backend_size_info
6318 #define elf_backend_size_info \
6319 _bfd_elf32_size_info
6321 #include "elf32-target.h"