1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2015 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "elf/x86-64.h"
41 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
42 #define MINUS_ONE (~ (bfd_vma) 0)
44 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
45 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
46 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
47 since they are the same. */
49 #define ABI_64_P(abfd) \
50 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52 /* The relocation "howto" table. Order of fields:
53 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
54 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
55 static reloc_howto_type x86_64_elf_howto_table
[] =
57 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
58 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
60 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
63 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
64 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
67 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
69 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
70 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
73 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
75 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
76 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
78 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
79 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
81 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
82 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
84 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
85 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
87 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
88 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
90 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
91 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
93 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
94 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
95 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
97 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
99 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
100 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
101 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
104 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
107 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
110 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
113 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
114 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
116 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
117 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
119 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
120 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
122 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
123 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
125 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
126 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
128 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
129 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
130 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
131 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
132 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
133 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
134 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
135 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
137 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
140 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
141 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
142 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
143 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
144 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
146 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
147 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
149 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
150 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
152 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
153 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
155 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
156 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
157 "R_X86_64_GOTPC32_TLSDESC",
158 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
159 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
160 complain_overflow_dont
, bfd_elf_generic_reloc
,
161 "R_X86_64_TLSDESC_CALL",
163 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
164 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
166 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
167 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
170 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
171 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
173 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
174 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
176 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
177 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 /* We have a gap in the reloc numbers here.
181 R_X86_64_standard counts the number up to this point, and
182 R_X86_64_vt_offset is the value to subtract from a reloc type of
183 R_X86_64_GNU_VT* to form an index into this table. */
184 #define R_X86_64_standard (R_X86_64_PLT32_BND + 1)
185 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
187 /* GNU extension to record C++ vtable hierarchy. */
188 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
189 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
191 /* GNU extension to record C++ vtable member usage. */
192 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
193 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
196 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
197 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
198 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
202 #define IS_X86_64_PCREL_TYPE(TYPE) \
203 ( ((TYPE) == R_X86_64_PC8) \
204 || ((TYPE) == R_X86_64_PC16) \
205 || ((TYPE) == R_X86_64_PC32) \
206 || ((TYPE) == R_X86_64_PC32_BND) \
207 || ((TYPE) == R_X86_64_PC64))
209 /* Map BFD relocs to the x86_64 elf relocs. */
212 bfd_reloc_code_real_type bfd_reloc_val
;
213 unsigned char elf_reloc_val
;
216 static const struct elf_reloc_map x86_64_reloc_map
[] =
218 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
219 { BFD_RELOC_64
, R_X86_64_64
, },
220 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
221 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
222 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
223 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
224 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
225 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
226 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
227 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
228 { BFD_RELOC_32
, R_X86_64_32
, },
229 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
230 { BFD_RELOC_16
, R_X86_64_16
, },
231 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
232 { BFD_RELOC_8
, R_X86_64_8
, },
233 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
234 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
235 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
236 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
237 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
238 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
239 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
240 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
241 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
242 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
243 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
244 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
245 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
246 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
247 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
248 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
249 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
250 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
251 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
252 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
253 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
254 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
255 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
256 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
,},
257 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
,},
258 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
259 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
262 static reloc_howto_type
*
263 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
267 if (r_type
== (unsigned int) R_X86_64_32
)
272 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
274 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
275 || r_type
>= (unsigned int) R_X86_64_max
)
277 if (r_type
>= (unsigned int) R_X86_64_standard
)
279 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
281 r_type
= R_X86_64_NONE
;
286 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
287 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
288 return &x86_64_elf_howto_table
[i
];
291 /* Given a BFD reloc type, return a HOWTO structure. */
292 static reloc_howto_type
*
293 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
294 bfd_reloc_code_real_type code
)
298 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
301 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
302 return elf_x86_64_rtype_to_howto (abfd
,
303 x86_64_reloc_map
[i
].elf_reloc_val
);
308 static reloc_howto_type
*
309 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
314 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
316 /* Get x32 R_X86_64_32. */
317 reloc_howto_type
*reloc
318 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
319 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
323 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
324 if (x86_64_elf_howto_table
[i
].name
!= NULL
325 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
326 return &x86_64_elf_howto_table
[i
];
331 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
334 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
335 Elf_Internal_Rela
*dst
)
339 r_type
= ELF32_R_TYPE (dst
->r_info
);
340 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
341 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
344 /* Support for core dump NOTE sections. */
346 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
351 switch (note
->descsz
)
356 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
358 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
361 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
369 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
371 elf_tdata (abfd
)->core
->signal
372 = bfd_get_16 (abfd
, note
->descdata
+ 12);
375 elf_tdata (abfd
)->core
->lwpid
376 = bfd_get_32 (abfd
, note
->descdata
+ 32);
385 /* Make a ".reg/999" section. */
386 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
387 size
, note
->descpos
+ offset
);
391 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
393 switch (note
->descsz
)
398 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
399 elf_tdata (abfd
)->core
->pid
400 = bfd_get_32 (abfd
, note
->descdata
+ 12);
401 elf_tdata (abfd
)->core
->program
402 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
403 elf_tdata (abfd
)->core
->command
404 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
407 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 24);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
416 /* Note that for some reason, a spurious space is tacked
417 onto the end of the args in some (at least one anyway)
418 implementations, so strip it off if it exists. */
421 char *command
= elf_tdata (abfd
)->core
->command
;
422 int n
= strlen (command
);
424 if (0 < n
&& command
[n
- 1] == ' ')
425 command
[n
- 1] = '\0';
433 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
436 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
438 const char *fname
, *psargs
;
449 va_start (ap
, note_type
);
450 fname
= va_arg (ap
, const char *);
451 psargs
= va_arg (ap
, const char *);
454 if (bed
->s
->elfclass
== ELFCLASS32
)
457 memset (&data
, 0, sizeof (data
));
458 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
459 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
460 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
461 &data
, sizeof (data
));
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 va_start (ap
, note_type
);
476 pid
= va_arg (ap
, long);
477 cursig
= va_arg (ap
, int);
478 gregs
= va_arg (ap
, const void *);
481 if (bed
->s
->elfclass
== ELFCLASS32
)
483 if (bed
->elf_machine_code
== EM_X86_64
)
485 prstatusx32_t prstat
;
486 memset (&prstat
, 0, sizeof (prstat
));
488 prstat
.pr_cursig
= cursig
;
489 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
490 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
491 &prstat
, sizeof (prstat
));
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
507 memset (&prstat
, 0, sizeof (prstat
));
509 prstat
.pr_cursig
= cursig
;
510 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
511 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
512 &prstat
, sizeof (prstat
));
519 /* Functions for the x86-64 ELF linker. */
521 /* The name of the dynamic interpreter. This is put in the .interp
524 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
525 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
527 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
528 copying dynamic variables from a shared lib into an app's dynbss
529 section, and instead use a dynamic relocation to point into the
531 #define ELIMINATE_COPY_RELOCS 1
533 /* The size in bytes of an entry in the global offset table. */
535 #define GOT_ENTRY_SIZE 8
537 /* The size in bytes of an entry in the procedure linkage table. */
539 #define PLT_ENTRY_SIZE 16
541 /* The first entry in a procedure linkage table looks like this. See the
542 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
544 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
546 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
547 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
548 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
551 /* Subsequent entries in a procedure linkage table look like this. */
553 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
556 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
557 0x68, /* pushq immediate */
558 0, 0, 0, 0, /* replaced with index into relocation table. */
559 0xe9, /* jmp relative */
560 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
563 /* The first entry in a procedure linkage table with BND relocations
566 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
568 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
569 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
570 0x0f, 0x1f, 0 /* nopl (%rax) */
573 /* Subsequent entries for legacy branches in a procedure linkage table
574 with BND relocations look like this. */
576 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
578 0x68, 0, 0, 0, 0, /* pushq immediate */
579 0xe9, 0, 0, 0, 0, /* jmpq relative */
580 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
583 /* Subsequent entries for branches with BND prefx in a procedure linkage
584 table with BND relocations look like this. */
586 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
588 0x68, 0, 0, 0, 0, /* pushq immediate */
589 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
590 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
593 /* Entries for legacy branches in the second procedure linkage table
596 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
598 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
599 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries for branches with BND prefix in the second procedure linkage
604 table look like this. */
606 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
608 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
613 /* .eh_frame covering the .plt section. */
615 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
617 #define PLT_CIE_LENGTH 20
618 #define PLT_FDE_LENGTH 36
619 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
620 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
621 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
622 0, 0, 0, 0, /* CIE ID */
624 'z', 'R', 0, /* Augmentation string */
625 1, /* Code alignment factor */
626 0x78, /* Data alignment factor */
627 16, /* Return address column */
628 1, /* Augmentation size */
629 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
630 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
631 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
632 DW_CFA_nop
, DW_CFA_nop
,
634 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
635 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
636 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
637 0, 0, 0, 0, /* .plt size goes here */
638 0, /* Augmentation size */
639 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
640 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
641 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
642 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
643 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
644 11, /* Block length */
645 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
646 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
647 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
648 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
649 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
652 /* Architecture-specific backend data for x86-64. */
654 struct elf_x86_64_backend_data
656 /* Templates for the initial PLT entry and for subsequent entries. */
657 const bfd_byte
*plt0_entry
;
658 const bfd_byte
*plt_entry
;
659 unsigned int plt_entry_size
; /* Size of each PLT entry. */
661 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
662 unsigned int plt0_got1_offset
;
663 unsigned int plt0_got2_offset
;
665 /* Offset of the end of the PC-relative instruction containing
667 unsigned int plt0_got2_insn_end
;
669 /* Offsets into plt_entry that are to be replaced with... */
670 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
671 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
672 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
674 /* Length of the PC-relative instruction containing plt_got_offset. */
675 unsigned int plt_got_insn_size
;
677 /* Offset of the end of the PC-relative jump to plt0_entry. */
678 unsigned int plt_plt_insn_end
;
680 /* Offset into plt_entry where the initial value of the GOT entry points. */
681 unsigned int plt_lazy_offset
;
683 /* .eh_frame covering the .plt section. */
684 const bfd_byte
*eh_frame_plt
;
685 unsigned int eh_frame_plt_size
;
688 #define get_elf_x86_64_arch_data(bed) \
689 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
691 #define get_elf_x86_64_backend_data(abfd) \
692 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
694 #define GET_PLT_ENTRY_SIZE(abfd) \
695 get_elf_x86_64_backend_data (abfd)->plt_entry_size
697 /* These are the standard parameters. */
698 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
700 elf_x86_64_plt0_entry
, /* plt0_entry */
701 elf_x86_64_plt_entry
, /* plt_entry */
702 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
703 2, /* plt0_got1_offset */
704 8, /* plt0_got2_offset */
705 12, /* plt0_got2_insn_end */
706 2, /* plt_got_offset */
707 7, /* plt_reloc_offset */
708 12, /* plt_plt_offset */
709 6, /* plt_got_insn_size */
710 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
711 6, /* plt_lazy_offset */
712 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
713 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
716 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
718 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
719 elf_x86_64_bnd_plt_entry
, /* plt_entry */
720 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
721 2, /* plt0_got1_offset */
722 1+8, /* plt0_got2_offset */
723 1+12, /* plt0_got2_insn_end */
724 1+2, /* plt_got_offset */
725 1, /* plt_reloc_offset */
726 7, /* plt_plt_offset */
727 1+6, /* plt_got_insn_size */
728 11, /* plt_plt_insn_end */
729 0, /* plt_lazy_offset */
730 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
731 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
734 #define elf_backend_arch_data &elf_x86_64_arch_bed
736 /* x86-64 ELF linker hash entry. */
738 struct elf_x86_64_link_hash_entry
740 struct elf_link_hash_entry elf
;
742 /* Track dynamic relocs copied for this symbol. */
743 struct elf_dyn_relocs
*dyn_relocs
;
745 #define GOT_UNKNOWN 0
749 #define GOT_TLS_GDESC 4
750 #define GOT_TLS_GD_BOTH_P(type) \
751 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
752 #define GOT_TLS_GD_P(type) \
753 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
754 #define GOT_TLS_GDESC_P(type) \
755 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
756 #define GOT_TLS_GD_ANY_P(type) \
757 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
758 unsigned char tls_type
;
760 /* TRUE if a weak symbol with a real definition needs a copy reloc.
761 When there is a weak symbol with a real definition, the processor
762 independent code will have arranged for us to see the real
763 definition first. We need to copy the needs_copy bit from the
764 real definition and check it when allowing copy reloc in PIE. */
765 unsigned int needs_copy
: 1;
767 /* TRUE if symbol has at least one BND relocation. */
768 unsigned int has_bnd_reloc
: 1;
770 /* Information about the GOT PLT entry. Filled when there are both
771 GOT and PLT relocations against the same function. */
772 union gotplt_union plt_got
;
774 /* Information about the second PLT entry. Filled when has_bnd_reloc is
776 union gotplt_union plt_bnd
;
778 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
779 starting at the end of the jump table. */
783 #define elf_x86_64_hash_entry(ent) \
784 ((struct elf_x86_64_link_hash_entry *)(ent))
786 struct elf_x86_64_obj_tdata
788 struct elf_obj_tdata root
;
790 /* tls_type for each local got entry. */
791 char *local_got_tls_type
;
793 /* GOTPLT entries for TLS descriptors. */
794 bfd_vma
*local_tlsdesc_gotent
;
797 #define elf_x86_64_tdata(abfd) \
798 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
800 #define elf_x86_64_local_got_tls_type(abfd) \
801 (elf_x86_64_tdata (abfd)->local_got_tls_type)
803 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
804 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
806 #define is_x86_64_elf(bfd) \
807 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
808 && elf_tdata (bfd) != NULL \
809 && elf_object_id (bfd) == X86_64_ELF_DATA)
812 elf_x86_64_mkobject (bfd
*abfd
)
814 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
818 /* x86-64 ELF linker hash table. */
820 struct elf_x86_64_link_hash_table
822 struct elf_link_hash_table elf
;
824 /* Short-cuts to get to dynamic linker sections. */
827 asection
*plt_eh_frame
;
833 bfd_signed_vma refcount
;
837 /* The amount of space used by the jump slots in the GOT. */
838 bfd_vma sgotplt_jump_table_size
;
840 /* Small local sym cache. */
841 struct sym_cache sym_cache
;
843 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
844 bfd_vma (*r_sym
) (bfd_vma
);
845 unsigned int pointer_r_type
;
846 const char *dynamic_interpreter
;
847 int dynamic_interpreter_size
;
849 /* _TLS_MODULE_BASE_ symbol. */
850 struct bfd_link_hash_entry
*tls_module_base
;
852 /* Used by local STT_GNU_IFUNC symbols. */
853 htab_t loc_hash_table
;
854 void * loc_hash_memory
;
856 /* The offset into splt of the PLT entry for the TLS descriptor
857 resolver. Special values are 0, if not necessary (or not found
858 to be necessary yet), and -1 if needed but not determined
861 /* The offset into sgot of the GOT entry used by the PLT entry
865 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
866 bfd_vma next_jump_slot_index
;
867 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
868 bfd_vma next_irelative_index
;
871 /* Get the x86-64 ELF linker hash table from a link_info structure. */
873 #define elf_x86_64_hash_table(p) \
874 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
875 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
877 #define elf_x86_64_compute_jump_table_size(htab) \
878 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
880 /* Create an entry in an x86-64 ELF linker hash table. */
882 static struct bfd_hash_entry
*
883 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
884 struct bfd_hash_table
*table
,
887 /* Allocate the structure if it has not already been allocated by a
891 entry
= (struct bfd_hash_entry
*)
892 bfd_hash_allocate (table
,
893 sizeof (struct elf_x86_64_link_hash_entry
));
898 /* Call the allocation method of the superclass. */
899 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
902 struct elf_x86_64_link_hash_entry
*eh
;
904 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
905 eh
->dyn_relocs
= NULL
;
906 eh
->tls_type
= GOT_UNKNOWN
;
908 eh
->has_bnd_reloc
= 0;
909 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
910 eh
->plt_got
.offset
= (bfd_vma
) -1;
911 eh
->tlsdesc_got
= (bfd_vma
) -1;
917 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
918 for local symbol so that we can handle local STT_GNU_IFUNC symbols
919 as global symbol. We reuse indx and dynstr_index for local symbol
920 hash since they aren't used by global symbols in this backend. */
923 elf_x86_64_local_htab_hash (const void *ptr
)
925 struct elf_link_hash_entry
*h
926 = (struct elf_link_hash_entry
*) ptr
;
927 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
930 /* Compare local hash entries. */
933 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
935 struct elf_link_hash_entry
*h1
936 = (struct elf_link_hash_entry
*) ptr1
;
937 struct elf_link_hash_entry
*h2
938 = (struct elf_link_hash_entry
*) ptr2
;
940 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
943 /* Find and/or create a hash entry for local symbol. */
945 static struct elf_link_hash_entry
*
946 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
947 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
950 struct elf_x86_64_link_hash_entry e
, *ret
;
951 asection
*sec
= abfd
->sections
;
952 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
953 htab
->r_sym (rel
->r_info
));
956 e
.elf
.indx
= sec
->id
;
957 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
958 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
959 create
? INSERT
: NO_INSERT
);
966 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
970 ret
= (struct elf_x86_64_link_hash_entry
*)
971 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
972 sizeof (struct elf_x86_64_link_hash_entry
));
975 memset (ret
, 0, sizeof (*ret
));
976 ret
->elf
.indx
= sec
->id
;
977 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
978 ret
->elf
.dynindx
= -1;
979 ret
->plt_got
.offset
= (bfd_vma
) -1;
985 /* Destroy an X86-64 ELF linker hash table. */
988 elf_x86_64_link_hash_table_free (bfd
*obfd
)
990 struct elf_x86_64_link_hash_table
*htab
991 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
993 if (htab
->loc_hash_table
)
994 htab_delete (htab
->loc_hash_table
);
995 if (htab
->loc_hash_memory
)
996 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
997 _bfd_elf_link_hash_table_free (obfd
);
1000 /* Create an X86-64 ELF linker hash table. */
1002 static struct bfd_link_hash_table
*
1003 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1005 struct elf_x86_64_link_hash_table
*ret
;
1006 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1008 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1012 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1013 elf_x86_64_link_hash_newfunc
,
1014 sizeof (struct elf_x86_64_link_hash_entry
),
1021 if (ABI_64_P (abfd
))
1023 ret
->r_info
= elf64_r_info
;
1024 ret
->r_sym
= elf64_r_sym
;
1025 ret
->pointer_r_type
= R_X86_64_64
;
1026 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1027 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1031 ret
->r_info
= elf32_r_info
;
1032 ret
->r_sym
= elf32_r_sym
;
1033 ret
->pointer_r_type
= R_X86_64_32
;
1034 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1035 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1038 ret
->loc_hash_table
= htab_try_create (1024,
1039 elf_x86_64_local_htab_hash
,
1040 elf_x86_64_local_htab_eq
,
1042 ret
->loc_hash_memory
= objalloc_create ();
1043 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1045 elf_x86_64_link_hash_table_free (abfd
);
1048 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1050 return &ret
->elf
.root
;
1053 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1054 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1059 struct bfd_link_info
*info
)
1061 struct elf_x86_64_link_hash_table
*htab
;
1063 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1066 htab
= elf_x86_64_hash_table (info
);
1070 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1074 if (info
->executable
)
1076 /* Always allow copy relocs for building executables. */
1077 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1080 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1081 s
= bfd_make_section_anyway_with_flags (dynobj
,
1083 (bed
->dynamic_sec_flags
1086 || ! bfd_set_section_alignment (dynobj
, s
,
1087 bed
->s
->log_file_align
))
1093 if (!info
->no_ld_generated_unwind_info
1094 && htab
->plt_eh_frame
== NULL
1095 && htab
->elf
.splt
!= NULL
)
1097 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1098 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1099 | SEC_LINKER_CREATED
);
1101 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1102 if (htab
->plt_eh_frame
== NULL
1103 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1109 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1112 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1113 struct elf_link_hash_entry
*dir
,
1114 struct elf_link_hash_entry
*ind
)
1116 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1118 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1119 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1121 if (!edir
->has_bnd_reloc
)
1122 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1124 if (eind
->dyn_relocs
!= NULL
)
1126 if (edir
->dyn_relocs
!= NULL
)
1128 struct elf_dyn_relocs
**pp
;
1129 struct elf_dyn_relocs
*p
;
1131 /* Add reloc counts against the indirect sym to the direct sym
1132 list. Merge any entries against the same section. */
1133 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1135 struct elf_dyn_relocs
*q
;
1137 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1138 if (q
->sec
== p
->sec
)
1140 q
->pc_count
+= p
->pc_count
;
1141 q
->count
+= p
->count
;
1148 *pp
= edir
->dyn_relocs
;
1151 edir
->dyn_relocs
= eind
->dyn_relocs
;
1152 eind
->dyn_relocs
= NULL
;
1155 if (ind
->root
.type
== bfd_link_hash_indirect
1156 && dir
->got
.refcount
<= 0)
1158 edir
->tls_type
= eind
->tls_type
;
1159 eind
->tls_type
= GOT_UNKNOWN
;
1162 if (ELIMINATE_COPY_RELOCS
1163 && ind
->root
.type
!= bfd_link_hash_indirect
1164 && dir
->dynamic_adjusted
)
1166 /* If called to transfer flags for a weakdef during processing
1167 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1168 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1169 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1170 dir
->ref_regular
|= ind
->ref_regular
;
1171 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1172 dir
->needs_plt
|= ind
->needs_plt
;
1173 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1176 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1180 elf64_x86_64_elf_object_p (bfd
*abfd
)
1182 /* Set the right machine number for an x86-64 elf64 file. */
1183 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1188 elf32_x86_64_elf_object_p (bfd
*abfd
)
1190 /* Set the right machine number for an x86-64 elf32 file. */
1191 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1195 /* Return TRUE if the TLS access code sequence support transition
1199 elf_x86_64_check_tls_transition (bfd
*abfd
,
1200 struct bfd_link_info
*info
,
1203 Elf_Internal_Shdr
*symtab_hdr
,
1204 struct elf_link_hash_entry
**sym_hashes
,
1205 unsigned int r_type
,
1206 const Elf_Internal_Rela
*rel
,
1207 const Elf_Internal_Rela
*relend
)
1210 unsigned long r_symndx
;
1211 bfd_boolean largepic
= FALSE
;
1212 struct elf_link_hash_entry
*h
;
1214 struct elf_x86_64_link_hash_table
*htab
;
1216 /* Get the section contents. */
1217 if (contents
== NULL
)
1219 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1220 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1223 /* FIXME: How to better handle error condition? */
1224 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1227 /* Cache the section contents for elf_link_input_bfd. */
1228 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1232 htab
= elf_x86_64_hash_table (info
);
1233 offset
= rel
->r_offset
;
1236 case R_X86_64_TLSGD
:
1237 case R_X86_64_TLSLD
:
1238 if ((rel
+ 1) >= relend
)
1241 if (r_type
== R_X86_64_TLSGD
)
1243 /* Check transition from GD access model. For 64bit, only
1244 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1245 .word 0x6666; rex64; call __tls_get_addr
1246 can transit to different access model. For 32bit, only
1247 leaq foo@tlsgd(%rip), %rdi
1248 .word 0x6666; rex64; call __tls_get_addr
1249 can transit to different access model. For largepic
1251 leaq foo@tlsgd(%rip), %rdi
1252 movabsq $__tls_get_addr@pltoff, %rax
1256 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1257 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1259 if ((offset
+ 12) > sec
->size
)
1262 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1264 if (!ABI_64_P (abfd
)
1265 || (offset
+ 19) > sec
->size
1267 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1268 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1269 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1274 else if (ABI_64_P (abfd
))
1277 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1283 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1289 /* Check transition from LD access model. Only
1290 leaq foo@tlsld(%rip), %rdi;
1292 can transit to different access model. For largepic
1294 leaq foo@tlsld(%rip), %rdi
1295 movabsq $__tls_get_addr@pltoff, %rax
1299 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1301 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1304 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1307 if (0xe8 != *(contents
+ offset
+ 4))
1309 if (!ABI_64_P (abfd
)
1310 || (offset
+ 19) > sec
->size
1311 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1312 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1319 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1320 if (r_symndx
< symtab_hdr
->sh_info
)
1323 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1324 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1325 may be versioned. */
1327 && h
->root
.root
.string
!= NULL
1329 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1330 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1331 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1332 && (strncmp (h
->root
.root
.string
,
1333 "__tls_get_addr", 14) == 0));
1335 case R_X86_64_GOTTPOFF
:
1336 /* Check transition from IE access model:
1337 mov foo@gottpoff(%rip), %reg
1338 add foo@gottpoff(%rip), %reg
1341 /* Check REX prefix first. */
1342 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1344 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1345 if (val
!= 0x48 && val
!= 0x4c)
1347 /* X32 may have 0x44 REX prefix or no REX prefix. */
1348 if (ABI_64_P (abfd
))
1354 /* X32 may not have any REX prefix. */
1355 if (ABI_64_P (abfd
))
1357 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1361 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1362 if (val
!= 0x8b && val
!= 0x03)
1365 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1366 return (val
& 0xc7) == 5;
1368 case R_X86_64_GOTPC32_TLSDESC
:
1369 /* Check transition from GDesc access model:
1370 leaq x@tlsdesc(%rip), %rax
1372 Make sure it's a leaq adding rip to a 32-bit offset
1373 into any register, although it's probably almost always
1376 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1379 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1380 if ((val
& 0xfb) != 0x48)
1383 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1386 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1387 return (val
& 0xc7) == 0x05;
1389 case R_X86_64_TLSDESC_CALL
:
1390 /* Check transition from GDesc access model:
1391 call *x@tlsdesc(%rax)
1393 if (offset
+ 2 <= sec
->size
)
1395 /* Make sure that it's a call *x@tlsdesc(%rax). */
1396 static const unsigned char call
[] = { 0xff, 0x10 };
1397 return memcmp (contents
+ offset
, call
, 2) == 0;
1407 /* Return TRUE if the TLS access transition is OK or no transition
1408 will be performed. Update R_TYPE if there is a transition. */
1411 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1412 asection
*sec
, bfd_byte
*contents
,
1413 Elf_Internal_Shdr
*symtab_hdr
,
1414 struct elf_link_hash_entry
**sym_hashes
,
1415 unsigned int *r_type
, int tls_type
,
1416 const Elf_Internal_Rela
*rel
,
1417 const Elf_Internal_Rela
*relend
,
1418 struct elf_link_hash_entry
*h
,
1419 unsigned long r_symndx
)
1421 unsigned int from_type
= *r_type
;
1422 unsigned int to_type
= from_type
;
1423 bfd_boolean check
= TRUE
;
1425 /* Skip TLS transition for functions. */
1427 && (h
->type
== STT_FUNC
1428 || h
->type
== STT_GNU_IFUNC
))
1433 case R_X86_64_TLSGD
:
1434 case R_X86_64_GOTPC32_TLSDESC
:
1435 case R_X86_64_TLSDESC_CALL
:
1436 case R_X86_64_GOTTPOFF
:
1437 if (info
->executable
)
1440 to_type
= R_X86_64_TPOFF32
;
1442 to_type
= R_X86_64_GOTTPOFF
;
1445 /* When we are called from elf_x86_64_relocate_section,
1446 CONTENTS isn't NULL and there may be additional transitions
1447 based on TLS_TYPE. */
1448 if (contents
!= NULL
)
1450 unsigned int new_to_type
= to_type
;
1452 if (info
->executable
1455 && tls_type
== GOT_TLS_IE
)
1456 new_to_type
= R_X86_64_TPOFF32
;
1458 if (to_type
== R_X86_64_TLSGD
1459 || to_type
== R_X86_64_GOTPC32_TLSDESC
1460 || to_type
== R_X86_64_TLSDESC_CALL
)
1462 if (tls_type
== GOT_TLS_IE
)
1463 new_to_type
= R_X86_64_GOTTPOFF
;
1466 /* We checked the transition before when we were called from
1467 elf_x86_64_check_relocs. We only want to check the new
1468 transition which hasn't been checked before. */
1469 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1470 to_type
= new_to_type
;
1475 case R_X86_64_TLSLD
:
1476 if (info
->executable
)
1477 to_type
= R_X86_64_TPOFF32
;
1484 /* Return TRUE if there is no transition. */
1485 if (from_type
== to_type
)
1488 /* Check if the transition can be performed. */
1490 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1491 symtab_hdr
, sym_hashes
,
1492 from_type
, rel
, relend
))
1494 reloc_howto_type
*from
, *to
;
1497 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1498 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1501 name
= h
->root
.root
.string
;
1504 struct elf_x86_64_link_hash_table
*htab
;
1506 htab
= elf_x86_64_hash_table (info
);
1511 Elf_Internal_Sym
*isym
;
1513 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1515 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1519 (*_bfd_error_handler
)
1520 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1521 "in section `%A' failed"),
1522 abfd
, sec
, from
->name
, to
->name
, name
,
1523 (unsigned long) rel
->r_offset
);
1524 bfd_set_error (bfd_error_bad_value
);
1532 /* Rename some of the generic section flags to better document how they
1534 #define need_convert_mov_to_lea sec_flg0
1536 /* Look through the relocs for a section during the first phase, and
1537 calculate needed space in the global offset table, procedure
1538 linkage table, and dynamic reloc sections. */
1541 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1543 const Elf_Internal_Rela
*relocs
)
1545 struct elf_x86_64_link_hash_table
*htab
;
1546 Elf_Internal_Shdr
*symtab_hdr
;
1547 struct elf_link_hash_entry
**sym_hashes
;
1548 const Elf_Internal_Rela
*rel
;
1549 const Elf_Internal_Rela
*rel_end
;
1551 bfd_boolean use_plt_got
;
1553 if (info
->relocatable
)
1556 BFD_ASSERT (is_x86_64_elf (abfd
));
1558 htab
= elf_x86_64_hash_table (info
);
1562 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1564 symtab_hdr
= &elf_symtab_hdr (abfd
);
1565 sym_hashes
= elf_sym_hashes (abfd
);
1569 rel_end
= relocs
+ sec
->reloc_count
;
1570 for (rel
= relocs
; rel
< rel_end
; rel
++)
1572 unsigned int r_type
;
1573 unsigned long r_symndx
;
1574 struct elf_link_hash_entry
*h
;
1575 Elf_Internal_Sym
*isym
;
1577 bfd_boolean size_reloc
;
1579 r_symndx
= htab
->r_sym (rel
->r_info
);
1580 r_type
= ELF32_R_TYPE (rel
->r_info
);
1582 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1584 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1589 if (r_symndx
< symtab_hdr
->sh_info
)
1591 /* A local symbol. */
1592 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1597 /* Check relocation against local STT_GNU_IFUNC symbol. */
1598 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1600 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1605 /* Fake a STT_GNU_IFUNC symbol. */
1606 h
->type
= STT_GNU_IFUNC
;
1609 h
->forced_local
= 1;
1610 h
->root
.type
= bfd_link_hash_defined
;
1618 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1619 while (h
->root
.type
== bfd_link_hash_indirect
1620 || h
->root
.type
== bfd_link_hash_warning
)
1621 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1624 /* Check invalid x32 relocations. */
1625 if (!ABI_64_P (abfd
))
1631 case R_X86_64_DTPOFF64
:
1632 case R_X86_64_TPOFF64
:
1634 case R_X86_64_GOTOFF64
:
1635 case R_X86_64_GOT64
:
1636 case R_X86_64_GOTPCREL64
:
1637 case R_X86_64_GOTPC64
:
1638 case R_X86_64_GOTPLT64
:
1639 case R_X86_64_PLTOFF64
:
1642 name
= h
->root
.root
.string
;
1644 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1646 (*_bfd_error_handler
)
1647 (_("%B: relocation %s against symbol `%s' isn't "
1648 "supported in x32 mode"), abfd
,
1649 x86_64_elf_howto_table
[r_type
].name
, name
);
1650 bfd_set_error (bfd_error_bad_value
);
1658 /* Create the ifunc sections for static executables. If we
1659 never see an indirect function symbol nor we are building
1660 a static executable, those sections will be empty and
1661 won't appear in output. */
1667 case R_X86_64_PC32_BND
:
1668 case R_X86_64_PLT32_BND
:
1670 case R_X86_64_PLT32
:
1673 /* MPX PLT is supported only if elf_x86_64_arch_bed
1674 is used in 64-bit mode. */
1677 && (get_elf_x86_64_backend_data (abfd
)
1678 == &elf_x86_64_arch_bed
))
1680 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1682 /* Create the second PLT for Intel MPX support. */
1683 if (htab
->plt_bnd
== NULL
)
1685 unsigned int plt_bnd_align
;
1686 const struct elf_backend_data
*bed
;
1688 bed
= get_elf_backend_data (info
->output_bfd
);
1689 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1690 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1691 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1694 if (htab
->elf
.dynobj
== NULL
)
1695 htab
->elf
.dynobj
= abfd
;
1697 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1699 (bed
->dynamic_sec_flags
1704 if (htab
->plt_bnd
== NULL
1705 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1714 case R_X86_64_GOTPCREL
:
1715 case R_X86_64_GOTPCREL64
:
1716 if (htab
->elf
.dynobj
== NULL
)
1717 htab
->elf
.dynobj
= abfd
;
1718 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1723 /* It is referenced by a non-shared object. */
1725 h
->root
.non_ir_ref
= 1;
1728 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1729 symtab_hdr
, sym_hashes
,
1730 &r_type
, GOT_UNKNOWN
,
1731 rel
, rel_end
, h
, r_symndx
))
1736 case R_X86_64_TLSLD
:
1737 htab
->tls_ld_got
.refcount
+= 1;
1740 case R_X86_64_TPOFF32
:
1741 if (!info
->executable
&& ABI_64_P (abfd
))
1744 name
= h
->root
.root
.string
;
1746 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1748 (*_bfd_error_handler
)
1749 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1751 x86_64_elf_howto_table
[r_type
].name
, name
);
1752 bfd_set_error (bfd_error_bad_value
);
1757 case R_X86_64_GOTTPOFF
:
1758 if (!info
->executable
)
1759 info
->flags
|= DF_STATIC_TLS
;
1762 case R_X86_64_GOT32
:
1763 case R_X86_64_GOTPCREL
:
1764 case R_X86_64_TLSGD
:
1765 case R_X86_64_GOT64
:
1766 case R_X86_64_GOTPCREL64
:
1767 case R_X86_64_GOTPLT64
:
1768 case R_X86_64_GOTPC32_TLSDESC
:
1769 case R_X86_64_TLSDESC_CALL
:
1770 /* This symbol requires a global offset table entry. */
1772 int tls_type
, old_tls_type
;
1776 default: tls_type
= GOT_NORMAL
; break;
1777 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1778 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1779 case R_X86_64_GOTPC32_TLSDESC
:
1780 case R_X86_64_TLSDESC_CALL
:
1781 tls_type
= GOT_TLS_GDESC
; break;
1786 h
->got
.refcount
+= 1;
1787 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1791 bfd_signed_vma
*local_got_refcounts
;
1793 /* This is a global offset table entry for a local symbol. */
1794 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1795 if (local_got_refcounts
== NULL
)
1799 size
= symtab_hdr
->sh_info
;
1800 size
*= sizeof (bfd_signed_vma
)
1801 + sizeof (bfd_vma
) + sizeof (char);
1802 local_got_refcounts
= ((bfd_signed_vma
*)
1803 bfd_zalloc (abfd
, size
));
1804 if (local_got_refcounts
== NULL
)
1806 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1807 elf_x86_64_local_tlsdesc_gotent (abfd
)
1808 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1809 elf_x86_64_local_got_tls_type (abfd
)
1810 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1812 local_got_refcounts
[r_symndx
] += 1;
1814 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1817 /* If a TLS symbol is accessed using IE at least once,
1818 there is no point to use dynamic model for it. */
1819 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1820 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1821 || tls_type
!= GOT_TLS_IE
))
1823 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1824 tls_type
= old_tls_type
;
1825 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1826 && GOT_TLS_GD_ANY_P (tls_type
))
1827 tls_type
|= old_tls_type
;
1831 name
= h
->root
.root
.string
;
1833 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1835 (*_bfd_error_handler
)
1836 (_("%B: '%s' accessed both as normal and thread local symbol"),
1838 bfd_set_error (bfd_error_bad_value
);
1843 if (old_tls_type
!= tls_type
)
1846 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1848 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1853 case R_X86_64_GOTOFF64
:
1854 case R_X86_64_GOTPC32
:
1855 case R_X86_64_GOTPC64
:
1857 if (htab
->elf
.sgot
== NULL
)
1859 if (htab
->elf
.dynobj
== NULL
)
1860 htab
->elf
.dynobj
= abfd
;
1861 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1867 case R_X86_64_PLT32
:
1868 case R_X86_64_PLT32_BND
:
1869 /* This symbol requires a procedure linkage table entry. We
1870 actually build the entry in adjust_dynamic_symbol,
1871 because this might be a case of linking PIC code which is
1872 never referenced by a dynamic object, in which case we
1873 don't need to generate a procedure linkage table entry
1876 /* If this is a local symbol, we resolve it directly without
1877 creating a procedure linkage table entry. */
1882 h
->plt
.refcount
+= 1;
1885 case R_X86_64_PLTOFF64
:
1886 /* This tries to form the 'address' of a function relative
1887 to GOT. For global symbols we need a PLT entry. */
1891 h
->plt
.refcount
+= 1;
1895 case R_X86_64_SIZE32
:
1896 case R_X86_64_SIZE64
:
1901 if (!ABI_64_P (abfd
))
1906 /* Let's help debug shared library creation. These relocs
1907 cannot be used in shared libs. Don't error out for
1908 sections we don't care about, such as debug sections or
1909 non-constant sections. */
1911 && (sec
->flags
& SEC_ALLOC
) != 0
1912 && (sec
->flags
& SEC_READONLY
) != 0)
1915 name
= h
->root
.root
.string
;
1917 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1918 (*_bfd_error_handler
)
1919 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1920 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1921 bfd_set_error (bfd_error_bad_value
);
1929 case R_X86_64_PC32_BND
:
1933 if (h
!= NULL
&& info
->executable
)
1935 /* If this reloc is in a read-only section, we might
1936 need a copy reloc. We can't check reliably at this
1937 stage whether the section is read-only, as input
1938 sections have not yet been mapped to output sections.
1939 Tentatively set the flag for now, and correct in
1940 adjust_dynamic_symbol. */
1943 /* We may need a .plt entry if the function this reloc
1944 refers to is in a shared lib. */
1945 h
->plt
.refcount
+= 1;
1946 if (r_type
!= R_X86_64_PC32
1947 && r_type
!= R_X86_64_PC32_BND
1948 && r_type
!= R_X86_64_PC64
)
1949 h
->pointer_equality_needed
= 1;
1954 /* If we are creating a shared library, and this is a reloc
1955 against a global symbol, or a non PC relative reloc
1956 against a local symbol, then we need to copy the reloc
1957 into the shared library. However, if we are linking with
1958 -Bsymbolic, we do not need to copy a reloc against a
1959 global symbol which is defined in an object we are
1960 including in the link (i.e., DEF_REGULAR is set). At
1961 this point we have not seen all the input files, so it is
1962 possible that DEF_REGULAR is not set now but will be set
1963 later (it is never cleared). In case of a weak definition,
1964 DEF_REGULAR may be cleared later by a strong definition in
1965 a shared library. We account for that possibility below by
1966 storing information in the relocs_copied field of the hash
1967 table entry. A similar situation occurs when creating
1968 shared libraries and symbol visibility changes render the
1971 If on the other hand, we are creating an executable, we
1972 may need to keep relocations for symbols satisfied by a
1973 dynamic library if we manage to avoid copy relocs for the
1976 && (sec
->flags
& SEC_ALLOC
) != 0
1977 && (! IS_X86_64_PCREL_TYPE (r_type
)
1979 && (! SYMBOLIC_BIND (info
, h
)
1980 || h
->root
.type
== bfd_link_hash_defweak
1981 || !h
->def_regular
))))
1982 || (ELIMINATE_COPY_RELOCS
1984 && (sec
->flags
& SEC_ALLOC
) != 0
1986 && (h
->root
.type
== bfd_link_hash_defweak
1987 || !h
->def_regular
)))
1989 struct elf_dyn_relocs
*p
;
1990 struct elf_dyn_relocs
**head
;
1992 /* We must copy these reloc types into the output file.
1993 Create a reloc section in dynobj and make room for
1997 if (htab
->elf
.dynobj
== NULL
)
1998 htab
->elf
.dynobj
= abfd
;
2000 sreloc
= _bfd_elf_make_dynamic_reloc_section
2001 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2002 abfd
, /*rela?*/ TRUE
);
2008 /* If this is a global symbol, we count the number of
2009 relocations we need for this symbol. */
2012 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
2016 /* Track dynamic relocs needed for local syms too.
2017 We really need local syms available to do this
2022 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2027 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2031 /* Beware of type punned pointers vs strict aliasing
2033 vpp
= &(elf_section_data (s
)->local_dynrel
);
2034 head
= (struct elf_dyn_relocs
**)vpp
;
2038 if (p
== NULL
|| p
->sec
!= sec
)
2040 bfd_size_type amt
= sizeof *p
;
2042 p
= ((struct elf_dyn_relocs
*)
2043 bfd_alloc (htab
->elf
.dynobj
, amt
));
2054 /* Count size relocation as PC-relative relocation. */
2055 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2060 /* This relocation describes the C++ object vtable hierarchy.
2061 Reconstruct it for later use during GC. */
2062 case R_X86_64_GNU_VTINHERIT
:
2063 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2067 /* This relocation describes which C++ vtable entries are actually
2068 used. Record for later use during GC. */
2069 case R_X86_64_GNU_VTENTRY
:
2070 BFD_ASSERT (h
!= NULL
);
2072 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2082 && h
->plt
.refcount
> 0
2083 && h
->got
.refcount
> 0
2084 && htab
->plt_got
== NULL
)
2086 /* Create the GOT procedure linkage table. */
2087 unsigned int plt_got_align
;
2088 const struct elf_backend_data
*bed
;
2090 bed
= get_elf_backend_data (info
->output_bfd
);
2091 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2092 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2093 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2096 if (htab
->elf
.dynobj
== NULL
)
2097 htab
->elf
.dynobj
= abfd
;
2099 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2101 (bed
->dynamic_sec_flags
2106 if (htab
->plt_got
== NULL
2107 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2113 if (r_type
== R_X86_64_GOTPCREL
2114 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2115 sec
->need_convert_mov_to_lea
= 1;
2121 /* Return the section that should be marked against GC for a given
2125 elf_x86_64_gc_mark_hook (asection
*sec
,
2126 struct bfd_link_info
*info
,
2127 Elf_Internal_Rela
*rel
,
2128 struct elf_link_hash_entry
*h
,
2129 Elf_Internal_Sym
*sym
)
2132 switch (ELF32_R_TYPE (rel
->r_info
))
2134 case R_X86_64_GNU_VTINHERIT
:
2135 case R_X86_64_GNU_VTENTRY
:
2139 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2142 /* Update the got entry reference counts for the section being removed. */
2145 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2147 const Elf_Internal_Rela
*relocs
)
2149 struct elf_x86_64_link_hash_table
*htab
;
2150 Elf_Internal_Shdr
*symtab_hdr
;
2151 struct elf_link_hash_entry
**sym_hashes
;
2152 bfd_signed_vma
*local_got_refcounts
;
2153 const Elf_Internal_Rela
*rel
, *relend
;
2155 if (info
->relocatable
)
2158 htab
= elf_x86_64_hash_table (info
);
2162 elf_section_data (sec
)->local_dynrel
= NULL
;
2164 symtab_hdr
= &elf_symtab_hdr (abfd
);
2165 sym_hashes
= elf_sym_hashes (abfd
);
2166 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2168 htab
= elf_x86_64_hash_table (info
);
2169 relend
= relocs
+ sec
->reloc_count
;
2170 for (rel
= relocs
; rel
< relend
; rel
++)
2172 unsigned long r_symndx
;
2173 unsigned int r_type
;
2174 struct elf_link_hash_entry
*h
= NULL
;
2176 r_symndx
= htab
->r_sym (rel
->r_info
);
2177 if (r_symndx
>= symtab_hdr
->sh_info
)
2179 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2180 while (h
->root
.type
== bfd_link_hash_indirect
2181 || h
->root
.type
== bfd_link_hash_warning
)
2182 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2186 /* A local symbol. */
2187 Elf_Internal_Sym
*isym
;
2189 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2192 /* Check relocation against local STT_GNU_IFUNC symbol. */
2194 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2196 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2204 struct elf_x86_64_link_hash_entry
*eh
;
2205 struct elf_dyn_relocs
**pp
;
2206 struct elf_dyn_relocs
*p
;
2208 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2210 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2213 /* Everything must go for SEC. */
2219 r_type
= ELF32_R_TYPE (rel
->r_info
);
2220 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2221 symtab_hdr
, sym_hashes
,
2222 &r_type
, GOT_UNKNOWN
,
2223 rel
, relend
, h
, r_symndx
))
2228 case R_X86_64_TLSLD
:
2229 if (htab
->tls_ld_got
.refcount
> 0)
2230 htab
->tls_ld_got
.refcount
-= 1;
2233 case R_X86_64_TLSGD
:
2234 case R_X86_64_GOTPC32_TLSDESC
:
2235 case R_X86_64_TLSDESC_CALL
:
2236 case R_X86_64_GOTTPOFF
:
2237 case R_X86_64_GOT32
:
2238 case R_X86_64_GOTPCREL
:
2239 case R_X86_64_GOT64
:
2240 case R_X86_64_GOTPCREL64
:
2241 case R_X86_64_GOTPLT64
:
2244 if (h
->got
.refcount
> 0)
2245 h
->got
.refcount
-= 1;
2246 if (h
->type
== STT_GNU_IFUNC
)
2248 if (h
->plt
.refcount
> 0)
2249 h
->plt
.refcount
-= 1;
2252 else if (local_got_refcounts
!= NULL
)
2254 if (local_got_refcounts
[r_symndx
] > 0)
2255 local_got_refcounts
[r_symndx
] -= 1;
2267 case R_X86_64_PC32_BND
:
2269 case R_X86_64_SIZE32
:
2270 case R_X86_64_SIZE64
:
2272 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2276 case R_X86_64_PLT32
:
2277 case R_X86_64_PLT32_BND
:
2278 case R_X86_64_PLTOFF64
:
2281 if (h
->plt
.refcount
> 0)
2282 h
->plt
.refcount
-= 1;
2294 /* Adjust a symbol defined by a dynamic object and referenced by a
2295 regular object. The current definition is in some section of the
2296 dynamic object, but we're not including those sections. We have to
2297 change the definition to something the rest of the link can
2301 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2302 struct elf_link_hash_entry
*h
)
2304 struct elf_x86_64_link_hash_table
*htab
;
2306 struct elf_x86_64_link_hash_entry
*eh
;
2307 struct elf_dyn_relocs
*p
;
2309 /* STT_GNU_IFUNC symbol must go through PLT. */
2310 if (h
->type
== STT_GNU_IFUNC
)
2312 /* All local STT_GNU_IFUNC references must be treate as local
2313 calls via local PLT. */
2315 && SYMBOL_CALLS_LOCAL (info
, h
))
2317 bfd_size_type pc_count
= 0, count
= 0;
2318 struct elf_dyn_relocs
**pp
;
2320 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2321 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2323 pc_count
+= p
->pc_count
;
2324 p
->count
-= p
->pc_count
;
2333 if (pc_count
|| count
)
2337 if (h
->plt
.refcount
<= 0)
2338 h
->plt
.refcount
= 1;
2340 h
->plt
.refcount
+= 1;
2344 if (h
->plt
.refcount
<= 0)
2346 h
->plt
.offset
= (bfd_vma
) -1;
2352 /* If this is a function, put it in the procedure linkage table. We
2353 will fill in the contents of the procedure linkage table later,
2354 when we know the address of the .got section. */
2355 if (h
->type
== STT_FUNC
2358 if (h
->plt
.refcount
<= 0
2359 || SYMBOL_CALLS_LOCAL (info
, h
)
2360 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2361 && h
->root
.type
== bfd_link_hash_undefweak
))
2363 /* This case can occur if we saw a PLT32 reloc in an input
2364 file, but the symbol was never referred to by a dynamic
2365 object, or if all references were garbage collected. In
2366 such a case, we don't actually need to build a procedure
2367 linkage table, and we can just do a PC32 reloc instead. */
2368 h
->plt
.offset
= (bfd_vma
) -1;
2375 /* It's possible that we incorrectly decided a .plt reloc was
2376 needed for an R_X86_64_PC32 reloc to a non-function sym in
2377 check_relocs. We can't decide accurately between function and
2378 non-function syms in check-relocs; Objects loaded later in
2379 the link may change h->type. So fix it now. */
2380 h
->plt
.offset
= (bfd_vma
) -1;
2382 /* If this is a weak symbol, and there is a real definition, the
2383 processor independent code will have arranged for us to see the
2384 real definition first, and we can just use the same value. */
2385 if (h
->u
.weakdef
!= NULL
)
2387 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2388 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2389 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2390 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2391 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2393 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2394 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2395 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2400 /* This is a reference to a symbol defined by a dynamic object which
2401 is not a function. */
2403 /* If we are creating a shared library, we must presume that the
2404 only references to the symbol are via the global offset table.
2405 For such cases we need not do anything here; the relocations will
2406 be handled correctly by relocate_section. */
2407 if (!info
->executable
)
2410 /* If there are no references to this symbol that do not use the
2411 GOT, we don't need to generate a copy reloc. */
2412 if (!h
->non_got_ref
)
2415 /* If -z nocopyreloc was given, we won't generate them either. */
2416 if (info
->nocopyreloc
)
2422 if (ELIMINATE_COPY_RELOCS
)
2424 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2425 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2427 s
= p
->sec
->output_section
;
2428 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2432 /* If we didn't find any dynamic relocs in read-only sections, then
2433 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2441 /* We must allocate the symbol in our .dynbss section, which will
2442 become part of the .bss section of the executable. There will be
2443 an entry for this symbol in the .dynsym section. The dynamic
2444 object will contain position independent code, so all references
2445 from the dynamic object to this symbol will go through the global
2446 offset table. The dynamic linker will use the .dynsym entry to
2447 determine the address it must put in the global offset table, so
2448 both the dynamic object and the regular object will refer to the
2449 same memory location for the variable. */
2451 htab
= elf_x86_64_hash_table (info
);
2455 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2456 to copy the initial value out of the dynamic object and into the
2457 runtime process image. */
2458 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2460 const struct elf_backend_data
*bed
;
2461 bed
= get_elf_backend_data (info
->output_bfd
);
2462 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2468 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2471 /* Allocate space in .plt, .got and associated reloc sections for
2475 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2477 struct bfd_link_info
*info
;
2478 struct elf_x86_64_link_hash_table
*htab
;
2479 struct elf_x86_64_link_hash_entry
*eh
;
2480 struct elf_dyn_relocs
*p
;
2481 const struct elf_backend_data
*bed
;
2482 unsigned int plt_entry_size
;
2484 if (h
->root
.type
== bfd_link_hash_indirect
)
2487 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2489 info
= (struct bfd_link_info
*) inf
;
2490 htab
= elf_x86_64_hash_table (info
);
2493 bed
= get_elf_backend_data (info
->output_bfd
);
2494 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2496 /* We can't use the GOT PLT if pointer equality is needed since
2497 finish_dynamic_symbol won't clear symbol value and the dynamic
2498 linker won't update the GOT slot. We will get into an infinite
2499 loop at run-time. */
2500 if (htab
->plt_got
!= NULL
2501 && h
->type
!= STT_GNU_IFUNC
2502 && !h
->pointer_equality_needed
2503 && h
->plt
.refcount
> 0
2504 && h
->got
.refcount
> 0)
2506 /* Don't use the regular PLT if there are both GOT and GOTPLT
2508 h
->plt
.offset
= (bfd_vma
) -1;
2510 /* Use the GOT PLT. */
2511 eh
->plt_got
.refcount
= 1;
2514 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2515 here if it is defined and referenced in a non-shared object. */
2516 if (h
->type
== STT_GNU_IFUNC
2519 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2525 asection
*s
= htab
->plt_bnd
;
2526 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2528 /* Use the .plt.bnd section if it is created. */
2529 eh
->plt_bnd
.offset
= s
->size
;
2531 /* Make room for this entry in the .plt.bnd section. */
2532 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2540 else if (htab
->elf
.dynamic_sections_created
2541 && (h
->plt
.refcount
> 0 || eh
->plt_got
.refcount
> 0))
2543 bfd_boolean use_plt_got
= eh
->plt_got
.refcount
> 0;
2545 /* Make sure this symbol is output as a dynamic symbol.
2546 Undefined weak syms won't yet be marked as dynamic. */
2547 if (h
->dynindx
== -1
2548 && !h
->forced_local
)
2550 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2555 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2557 asection
*s
= htab
->elf
.splt
;
2558 asection
*bnd_s
= htab
->plt_bnd
;
2559 asection
*got_s
= htab
->plt_got
;
2561 /* If this is the first .plt entry, make room for the special
2564 s
->size
= plt_entry_size
;
2567 eh
->plt_got
.offset
= got_s
->size
;
2570 h
->plt
.offset
= s
->size
;
2572 eh
->plt_bnd
.offset
= bnd_s
->size
;
2575 /* If this symbol is not defined in a regular file, and we are
2576 not generating a shared library, then set the symbol to this
2577 location in the .plt. This is required to make function
2578 pointers compare as equal between the normal executable and
2579 the shared library. */
2585 /* We need to make a call to the entry of the GOT PLT
2586 instead of regular PLT entry. */
2587 h
->root
.u
.def
.section
= got_s
;
2588 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2594 /* We need to make a call to the entry of the second
2595 PLT instead of regular PLT entry. */
2596 h
->root
.u
.def
.section
= bnd_s
;
2597 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2601 h
->root
.u
.def
.section
= s
;
2602 h
->root
.u
.def
.value
= h
->plt
.offset
;
2607 /* Make room for this entry. */
2609 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2612 s
->size
+= plt_entry_size
;
2614 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2616 /* We also need to make an entry in the .got.plt section,
2617 which will be placed in the .got section by the linker
2619 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2621 /* We also need to make an entry in the .rela.plt
2623 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2624 htab
->elf
.srelplt
->reloc_count
++;
2629 h
->plt
.offset
= (bfd_vma
) -1;
2635 h
->plt
.offset
= (bfd_vma
) -1;
2639 eh
->tlsdesc_got
= (bfd_vma
) -1;
2641 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2642 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2643 if (h
->got
.refcount
> 0
2646 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2648 h
->got
.offset
= (bfd_vma
) -1;
2650 else if (h
->got
.refcount
> 0)
2654 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2656 /* Make sure this symbol is output as a dynamic symbol.
2657 Undefined weak syms won't yet be marked as dynamic. */
2658 if (h
->dynindx
== -1
2659 && !h
->forced_local
)
2661 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2665 if (GOT_TLS_GDESC_P (tls_type
))
2667 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2668 - elf_x86_64_compute_jump_table_size (htab
);
2669 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2670 h
->got
.offset
= (bfd_vma
) -2;
2672 if (! GOT_TLS_GDESC_P (tls_type
)
2673 || GOT_TLS_GD_P (tls_type
))
2676 h
->got
.offset
= s
->size
;
2677 s
->size
+= GOT_ENTRY_SIZE
;
2678 if (GOT_TLS_GD_P (tls_type
))
2679 s
->size
+= GOT_ENTRY_SIZE
;
2681 dyn
= htab
->elf
.dynamic_sections_created
;
2682 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2684 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2685 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2686 || tls_type
== GOT_TLS_IE
)
2687 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2688 else if (GOT_TLS_GD_P (tls_type
))
2689 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2690 else if (! GOT_TLS_GDESC_P (tls_type
)
2691 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2692 || h
->root
.type
!= bfd_link_hash_undefweak
)
2694 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2695 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2696 if (GOT_TLS_GDESC_P (tls_type
))
2698 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2699 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2703 h
->got
.offset
= (bfd_vma
) -1;
2705 if (eh
->dyn_relocs
== NULL
)
2708 /* In the shared -Bsymbolic case, discard space allocated for
2709 dynamic pc-relative relocs against symbols which turn out to be
2710 defined in regular objects. For the normal shared case, discard
2711 space for pc-relative relocs that have become local due to symbol
2712 visibility changes. */
2716 /* Relocs that use pc_count are those that appear on a call
2717 insn, or certain REL relocs that can generated via assembly.
2718 We want calls to protected symbols to resolve directly to the
2719 function rather than going via the plt. If people want
2720 function pointer comparisons to work as expected then they
2721 should avoid writing weird assembly. */
2722 if (SYMBOL_CALLS_LOCAL (info
, h
))
2724 struct elf_dyn_relocs
**pp
;
2726 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2728 p
->count
-= p
->pc_count
;
2737 /* Also discard relocs on undefined weak syms with non-default
2739 if (eh
->dyn_relocs
!= NULL
)
2741 if (h
->root
.type
== bfd_link_hash_undefweak
)
2743 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2744 eh
->dyn_relocs
= NULL
;
2746 /* Make sure undefined weak symbols are output as a dynamic
2748 else if (h
->dynindx
== -1
2749 && ! h
->forced_local
2750 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2753 /* For PIE, discard space for pc-relative relocs against
2754 symbols which turn out to need copy relocs. */
2755 else if (info
->executable
2756 && (h
->needs_copy
|| eh
->needs_copy
)
2760 struct elf_dyn_relocs
**pp
;
2762 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2764 if (p
->pc_count
!= 0)
2772 else if (ELIMINATE_COPY_RELOCS
)
2774 /* For the non-shared case, discard space for relocs against
2775 symbols which turn out to need copy relocs or are not
2781 || (htab
->elf
.dynamic_sections_created
2782 && (h
->root
.type
== bfd_link_hash_undefweak
2783 || h
->root
.type
== bfd_link_hash_undefined
))))
2785 /* Make sure this symbol is output as a dynamic symbol.
2786 Undefined weak syms won't yet be marked as dynamic. */
2787 if (h
->dynindx
== -1
2788 && ! h
->forced_local
2789 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2792 /* If that succeeded, we know we'll be keeping all the
2794 if (h
->dynindx
!= -1)
2798 eh
->dyn_relocs
= NULL
;
2803 /* Finally, allocate space. */
2804 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2808 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2810 BFD_ASSERT (sreloc
!= NULL
);
2812 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2818 /* Allocate space in .plt, .got and associated reloc sections for
2819 local dynamic relocs. */
2822 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2824 struct elf_link_hash_entry
*h
2825 = (struct elf_link_hash_entry
*) *slot
;
2827 if (h
->type
!= STT_GNU_IFUNC
2831 || h
->root
.type
!= bfd_link_hash_defined
)
2834 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2837 /* Find any dynamic relocs that apply to read-only sections. */
2840 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2843 struct elf_x86_64_link_hash_entry
*eh
;
2844 struct elf_dyn_relocs
*p
;
2846 /* Skip local IFUNC symbols. */
2847 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2850 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2851 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2853 asection
*s
= p
->sec
->output_section
;
2855 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2857 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2859 info
->flags
|= DF_TEXTREL
;
2861 if ((info
->warn_shared_textrel
&& info
->shared
)
2862 || info
->error_textrel
)
2863 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2864 p
->sec
->owner
, h
->root
.root
.string
,
2867 /* Not an error, just cut short the traversal. */
2875 mov foo@GOTPCREL(%rip), %reg
2878 with the local symbol, foo. */
2881 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2882 struct bfd_link_info
*link_info
)
2884 Elf_Internal_Shdr
*symtab_hdr
;
2885 Elf_Internal_Rela
*internal_relocs
;
2886 Elf_Internal_Rela
*irel
, *irelend
;
2888 struct elf_x86_64_link_hash_table
*htab
;
2889 bfd_boolean changed_contents
;
2890 bfd_boolean changed_relocs
;
2891 bfd_signed_vma
*local_got_refcounts
;
2893 /* Don't even try to convert non-ELF outputs. */
2894 if (!is_elf_hash_table (link_info
->hash
))
2897 /* Nothing to do if there is no need or no output. */
2898 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2899 || sec
->need_convert_mov_to_lea
== 0
2900 || bfd_is_abs_section (sec
->output_section
))
2903 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2905 /* Load the relocations for this section. */
2906 internal_relocs
= (_bfd_elf_link_read_relocs
2907 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2908 link_info
->keep_memory
));
2909 if (internal_relocs
== NULL
)
2912 htab
= elf_x86_64_hash_table (link_info
);
2913 changed_contents
= FALSE
;
2914 changed_relocs
= FALSE
;
2915 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2917 /* Get the section contents. */
2918 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2919 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2922 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2926 irelend
= internal_relocs
+ sec
->reloc_count
;
2927 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2929 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2930 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2932 struct elf_link_hash_entry
*h
;
2934 if (r_type
!= R_X86_64_GOTPCREL
)
2937 /* Get the symbol referred to by the reloc. */
2938 if (r_symndx
< symtab_hdr
->sh_info
)
2940 Elf_Internal_Sym
*isym
;
2942 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2945 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2946 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2947 && irel
->r_offset
>= 2
2948 && bfd_get_8 (input_bfd
,
2949 contents
+ irel
->r_offset
- 2) == 0x8b)
2951 bfd_put_8 (output_bfd
, 0x8d,
2952 contents
+ irel
->r_offset
- 2);
2953 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2954 if (local_got_refcounts
!= NULL
2955 && local_got_refcounts
[r_symndx
] > 0)
2956 local_got_refcounts
[r_symndx
] -= 1;
2957 changed_contents
= TRUE
;
2958 changed_relocs
= TRUE
;
2963 indx
= r_symndx
- symtab_hdr
->sh_info
;
2964 h
= elf_sym_hashes (abfd
)[indx
];
2965 BFD_ASSERT (h
!= NULL
);
2967 while (h
->root
.type
== bfd_link_hash_indirect
2968 || h
->root
.type
== bfd_link_hash_warning
)
2969 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2971 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2972 avoid optimizing _DYNAMIC since ld.so may use its link-time
2975 && h
->type
!= STT_GNU_IFUNC
2976 && h
!= htab
->elf
.hdynamic
2977 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2978 && irel
->r_offset
>= 2
2979 && bfd_get_8 (input_bfd
,
2980 contents
+ irel
->r_offset
- 2) == 0x8b)
2982 bfd_put_8 (output_bfd
, 0x8d,
2983 contents
+ irel
->r_offset
- 2);
2984 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2985 if (h
->got
.refcount
> 0)
2986 h
->got
.refcount
-= 1;
2987 changed_contents
= TRUE
;
2988 changed_relocs
= TRUE
;
2992 if (contents
!= NULL
2993 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2995 if (!changed_contents
&& !link_info
->keep_memory
)
2999 /* Cache the section contents for elf_link_input_bfd. */
3000 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3004 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3006 if (!changed_relocs
)
3007 free (internal_relocs
);
3009 elf_section_data (sec
)->relocs
= internal_relocs
;
3015 if (contents
!= NULL
3016 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3018 if (internal_relocs
!= NULL
3019 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3020 free (internal_relocs
);
3024 /* Set the sizes of the dynamic sections. */
3027 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3028 struct bfd_link_info
*info
)
3030 struct elf_x86_64_link_hash_table
*htab
;
3035 const struct elf_backend_data
*bed
;
3037 htab
= elf_x86_64_hash_table (info
);
3040 bed
= get_elf_backend_data (output_bfd
);
3042 dynobj
= htab
->elf
.dynobj
;
3046 if (htab
->elf
.dynamic_sections_created
)
3048 /* Set the contents of the .interp section to the interpreter. */
3049 if (info
->executable
)
3051 s
= bfd_get_linker_section (dynobj
, ".interp");
3054 s
->size
= htab
->dynamic_interpreter_size
;
3055 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3059 /* Set up .got offsets for local syms, and space for local dynamic
3061 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3063 bfd_signed_vma
*local_got
;
3064 bfd_signed_vma
*end_local_got
;
3065 char *local_tls_type
;
3066 bfd_vma
*local_tlsdesc_gotent
;
3067 bfd_size_type locsymcount
;
3068 Elf_Internal_Shdr
*symtab_hdr
;
3071 if (! is_x86_64_elf (ibfd
))
3074 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3076 struct elf_dyn_relocs
*p
;
3078 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
3081 for (p
= (struct elf_dyn_relocs
*)
3082 (elf_section_data (s
)->local_dynrel
);
3086 if (!bfd_is_abs_section (p
->sec
)
3087 && bfd_is_abs_section (p
->sec
->output_section
))
3089 /* Input section has been discarded, either because
3090 it is a copy of a linkonce section or due to
3091 linker script /DISCARD/, so we'll be discarding
3094 else if (p
->count
!= 0)
3096 srel
= elf_section_data (p
->sec
)->sreloc
;
3097 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3098 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3099 && (info
->flags
& DF_TEXTREL
) == 0)
3101 info
->flags
|= DF_TEXTREL
;
3102 if ((info
->warn_shared_textrel
&& info
->shared
)
3103 || info
->error_textrel
)
3104 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3105 p
->sec
->owner
, p
->sec
);
3111 local_got
= elf_local_got_refcounts (ibfd
);
3115 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3116 locsymcount
= symtab_hdr
->sh_info
;
3117 end_local_got
= local_got
+ locsymcount
;
3118 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3119 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3121 srel
= htab
->elf
.srelgot
;
3122 for (; local_got
< end_local_got
;
3123 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3125 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3128 if (GOT_TLS_GDESC_P (*local_tls_type
))
3130 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3131 - elf_x86_64_compute_jump_table_size (htab
);
3132 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3133 *local_got
= (bfd_vma
) -2;
3135 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3136 || GOT_TLS_GD_P (*local_tls_type
))
3138 *local_got
= s
->size
;
3139 s
->size
+= GOT_ENTRY_SIZE
;
3140 if (GOT_TLS_GD_P (*local_tls_type
))
3141 s
->size
+= GOT_ENTRY_SIZE
;
3144 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3145 || *local_tls_type
== GOT_TLS_IE
)
3147 if (GOT_TLS_GDESC_P (*local_tls_type
))
3149 htab
->elf
.srelplt
->size
3150 += bed
->s
->sizeof_rela
;
3151 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3153 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3154 || GOT_TLS_GD_P (*local_tls_type
))
3155 srel
->size
+= bed
->s
->sizeof_rela
;
3159 *local_got
= (bfd_vma
) -1;
3163 if (htab
->tls_ld_got
.refcount
> 0)
3165 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3167 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3168 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3169 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3172 htab
->tls_ld_got
.offset
= -1;
3174 /* Allocate global sym .plt and .got entries, and space for global
3175 sym dynamic relocs. */
3176 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3179 /* Allocate .plt and .got entries, and space for local symbols. */
3180 htab_traverse (htab
->loc_hash_table
,
3181 elf_x86_64_allocate_local_dynrelocs
,
3184 /* For every jump slot reserved in the sgotplt, reloc_count is
3185 incremented. However, when we reserve space for TLS descriptors,
3186 it's not incremented, so in order to compute the space reserved
3187 for them, it suffices to multiply the reloc count by the jump
3190 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3191 so that R_X86_64_IRELATIVE entries come last. */
3192 if (htab
->elf
.srelplt
)
3194 htab
->sgotplt_jump_table_size
3195 = elf_x86_64_compute_jump_table_size (htab
);
3196 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3198 else if (htab
->elf
.irelplt
)
3199 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3201 if (htab
->tlsdesc_plt
)
3203 /* If we're not using lazy TLS relocations, don't generate the
3204 PLT and GOT entries they require. */
3205 if ((info
->flags
& DF_BIND_NOW
))
3206 htab
->tlsdesc_plt
= 0;
3209 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3210 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3211 /* Reserve room for the initial entry.
3212 FIXME: we could probably do away with it in this case. */
3213 if (htab
->elf
.splt
->size
== 0)
3214 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3215 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3216 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3220 if (htab
->elf
.sgotplt
)
3222 /* Don't allocate .got.plt section if there are no GOT nor PLT
3223 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3224 if ((htab
->elf
.hgot
== NULL
3225 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3226 && (htab
->elf
.sgotplt
->size
3227 == get_elf_backend_data (output_bfd
)->got_header_size
)
3228 && (htab
->elf
.splt
== NULL
3229 || htab
->elf
.splt
->size
== 0)
3230 && (htab
->elf
.sgot
== NULL
3231 || htab
->elf
.sgot
->size
== 0)
3232 && (htab
->elf
.iplt
== NULL
3233 || htab
->elf
.iplt
->size
== 0)
3234 && (htab
->elf
.igotplt
== NULL
3235 || htab
->elf
.igotplt
->size
== 0))
3236 htab
->elf
.sgotplt
->size
= 0;
3239 if (htab
->plt_eh_frame
!= NULL
3240 && htab
->elf
.splt
!= NULL
3241 && htab
->elf
.splt
->size
!= 0
3242 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3243 && _bfd_elf_eh_frame_present (info
))
3245 const struct elf_x86_64_backend_data
*arch_data
3246 = get_elf_x86_64_arch_data (bed
);
3247 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3250 /* We now have determined the sizes of the various dynamic sections.
3251 Allocate memory for them. */
3253 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3255 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3258 if (s
== htab
->elf
.splt
3259 || s
== htab
->elf
.sgot
3260 || s
== htab
->elf
.sgotplt
3261 || s
== htab
->elf
.iplt
3262 || s
== htab
->elf
.igotplt
3263 || s
== htab
->plt_bnd
3264 || s
== htab
->plt_got
3265 || s
== htab
->plt_eh_frame
3266 || s
== htab
->sdynbss
)
3268 /* Strip this section if we don't need it; see the
3271 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3273 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3276 /* We use the reloc_count field as a counter if we need
3277 to copy relocs into the output file. */
3278 if (s
!= htab
->elf
.srelplt
)
3283 /* It's not one of our sections, so don't allocate space. */
3289 /* If we don't need this section, strip it from the
3290 output file. This is mostly to handle .rela.bss and
3291 .rela.plt. We must create both sections in
3292 create_dynamic_sections, because they must be created
3293 before the linker maps input sections to output
3294 sections. The linker does that before
3295 adjust_dynamic_symbol is called, and it is that
3296 function which decides whether anything needs to go
3297 into these sections. */
3299 s
->flags
|= SEC_EXCLUDE
;
3303 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3306 /* Allocate memory for the section contents. We use bfd_zalloc
3307 here in case unused entries are not reclaimed before the
3308 section's contents are written out. This should not happen,
3309 but this way if it does, we get a R_X86_64_NONE reloc instead
3311 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3312 if (s
->contents
== NULL
)
3316 if (htab
->plt_eh_frame
!= NULL
3317 && htab
->plt_eh_frame
->contents
!= NULL
)
3319 const struct elf_x86_64_backend_data
*arch_data
3320 = get_elf_x86_64_arch_data (bed
);
3322 memcpy (htab
->plt_eh_frame
->contents
,
3323 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3324 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3325 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3328 if (htab
->elf
.dynamic_sections_created
)
3330 /* Add some entries to the .dynamic section. We fill in the
3331 values later, in elf_x86_64_finish_dynamic_sections, but we
3332 must add the entries now so that we get the correct size for
3333 the .dynamic section. The DT_DEBUG entry is filled in by the
3334 dynamic linker and used by the debugger. */
3335 #define add_dynamic_entry(TAG, VAL) \
3336 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3338 if (info
->executable
)
3340 if (!add_dynamic_entry (DT_DEBUG
, 0))
3344 if (htab
->elf
.splt
->size
!= 0)
3346 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3347 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3348 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3349 || !add_dynamic_entry (DT_JMPREL
, 0))
3352 if (htab
->tlsdesc_plt
3353 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3354 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3360 if (!add_dynamic_entry (DT_RELA
, 0)
3361 || !add_dynamic_entry (DT_RELASZ
, 0)
3362 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3365 /* If any dynamic relocs apply to a read-only section,
3366 then we need a DT_TEXTREL entry. */
3367 if ((info
->flags
& DF_TEXTREL
) == 0)
3368 elf_link_hash_traverse (&htab
->elf
,
3369 elf_x86_64_readonly_dynrelocs
,
3372 if ((info
->flags
& DF_TEXTREL
) != 0)
3374 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3379 #undef add_dynamic_entry
3385 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3386 struct bfd_link_info
*info
)
3388 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3392 struct elf_link_hash_entry
*tlsbase
;
3394 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3395 "_TLS_MODULE_BASE_",
3396 FALSE
, FALSE
, FALSE
);
3398 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3400 struct elf_x86_64_link_hash_table
*htab
;
3401 struct bfd_link_hash_entry
*bh
= NULL
;
3402 const struct elf_backend_data
*bed
3403 = get_elf_backend_data (output_bfd
);
3405 htab
= elf_x86_64_hash_table (info
);
3409 if (!(_bfd_generic_link_add_one_symbol
3410 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3411 tls_sec
, 0, NULL
, FALSE
,
3412 bed
->collect
, &bh
)))
3415 htab
->tls_module_base
= bh
;
3417 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3418 tlsbase
->def_regular
= 1;
3419 tlsbase
->other
= STV_HIDDEN
;
3420 tlsbase
->root
.linker_def
= 1;
3421 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3428 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3429 executables. Rather than setting it to the beginning of the TLS
3430 section, we have to set it to the end. This function may be called
3431 multiple times, it is idempotent. */
3434 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3436 struct elf_x86_64_link_hash_table
*htab
;
3437 struct bfd_link_hash_entry
*base
;
3439 if (!info
->executable
)
3442 htab
= elf_x86_64_hash_table (info
);
3446 base
= htab
->tls_module_base
;
3450 base
->u
.def
.value
= htab
->elf
.tls_size
;
3453 /* Return the base VMA address which should be subtracted from real addresses
3454 when resolving @dtpoff relocation.
3455 This is PT_TLS segment p_vaddr. */
3458 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3460 /* If tls_sec is NULL, we should have signalled an error already. */
3461 if (elf_hash_table (info
)->tls_sec
== NULL
)
3463 return elf_hash_table (info
)->tls_sec
->vma
;
3466 /* Return the relocation value for @tpoff relocation
3467 if STT_TLS virtual address is ADDRESS. */
3470 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3472 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3473 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3474 bfd_vma static_tls_size
;
3476 /* If tls_segment is NULL, we should have signalled an error already. */
3477 if (htab
->tls_sec
== NULL
)
3480 /* Consider special static TLS alignment requirements. */
3481 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3482 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3485 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3489 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3491 /* Opcode Instruction
3494 0x0f 0x8x conditional jump */
3496 && (contents
[offset
- 1] == 0xe8
3497 || contents
[offset
- 1] == 0xe9))
3499 && contents
[offset
- 2] == 0x0f
3500 && (contents
[offset
- 1] & 0xf0) == 0x80));
3503 /* Relocate an x86_64 ELF section. */
3506 elf_x86_64_relocate_section (bfd
*output_bfd
,
3507 struct bfd_link_info
*info
,
3509 asection
*input_section
,
3511 Elf_Internal_Rela
*relocs
,
3512 Elf_Internal_Sym
*local_syms
,
3513 asection
**local_sections
)
3515 struct elf_x86_64_link_hash_table
*htab
;
3516 Elf_Internal_Shdr
*symtab_hdr
;
3517 struct elf_link_hash_entry
**sym_hashes
;
3518 bfd_vma
*local_got_offsets
;
3519 bfd_vma
*local_tlsdesc_gotents
;
3520 Elf_Internal_Rela
*rel
;
3521 Elf_Internal_Rela
*relend
;
3522 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3524 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3526 htab
= elf_x86_64_hash_table (info
);
3529 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3530 sym_hashes
= elf_sym_hashes (input_bfd
);
3531 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3532 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3534 elf_x86_64_set_tls_module_base (info
);
3537 relend
= relocs
+ input_section
->reloc_count
;
3538 for (; rel
< relend
; rel
++)
3540 unsigned int r_type
;
3541 reloc_howto_type
*howto
;
3542 unsigned long r_symndx
;
3543 struct elf_link_hash_entry
*h
;
3544 struct elf_x86_64_link_hash_entry
*eh
;
3545 Elf_Internal_Sym
*sym
;
3547 bfd_vma off
, offplt
, plt_offset
;
3549 bfd_boolean unresolved_reloc
;
3550 bfd_reloc_status_type r
;
3552 asection
*base_got
, *resolved_plt
;
3555 r_type
= ELF32_R_TYPE (rel
->r_info
);
3556 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3557 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3560 if (r_type
>= (int) R_X86_64_standard
)
3562 (*_bfd_error_handler
)
3563 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3564 input_bfd
, input_section
, r_type
);
3565 bfd_set_error (bfd_error_bad_value
);
3569 if (r_type
!= (int) R_X86_64_32
3570 || ABI_64_P (output_bfd
))
3571 howto
= x86_64_elf_howto_table
+ r_type
;
3573 howto
= (x86_64_elf_howto_table
3574 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3575 r_symndx
= htab
->r_sym (rel
->r_info
);
3579 unresolved_reloc
= FALSE
;
3580 if (r_symndx
< symtab_hdr
->sh_info
)
3582 sym
= local_syms
+ r_symndx
;
3583 sec
= local_sections
[r_symndx
];
3585 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3587 st_size
= sym
->st_size
;
3589 /* Relocate against local STT_GNU_IFUNC symbol. */
3590 if (!info
->relocatable
3591 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3593 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3598 /* Set STT_GNU_IFUNC symbol value. */
3599 h
->root
.u
.def
.value
= sym
->st_value
;
3600 h
->root
.u
.def
.section
= sec
;
3605 bfd_boolean warned ATTRIBUTE_UNUSED
;
3606 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3608 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3609 r_symndx
, symtab_hdr
, sym_hashes
,
3611 unresolved_reloc
, warned
, ignored
);
3615 if (sec
!= NULL
&& discarded_section (sec
))
3616 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3617 rel
, 1, relend
, howto
, 0, contents
);
3619 if (info
->relocatable
)
3622 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3624 if (r_type
== R_X86_64_64
)
3626 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3627 zero-extend it to 64bit if addend is zero. */
3628 r_type
= R_X86_64_32
;
3629 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3631 else if (r_type
== R_X86_64_SIZE64
)
3633 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3634 zero-extend it to 64bit if addend is zero. */
3635 r_type
= R_X86_64_SIZE32
;
3636 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3640 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3642 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3643 it here if it is defined in a non-shared object. */
3645 && h
->type
== STT_GNU_IFUNC
3651 if ((input_section
->flags
& SEC_ALLOC
) == 0
3652 || h
->plt
.offset
== (bfd_vma
) -1)
3655 /* STT_GNU_IFUNC symbol must go through PLT. */
3656 if (htab
->elf
.splt
!= NULL
)
3658 if (htab
->plt_bnd
!= NULL
)
3660 resolved_plt
= htab
->plt_bnd
;
3661 plt_offset
= eh
->plt_bnd
.offset
;
3665 resolved_plt
= htab
->elf
.splt
;
3666 plt_offset
= h
->plt
.offset
;
3671 resolved_plt
= htab
->elf
.iplt
;
3672 plt_offset
= h
->plt
.offset
;
3675 relocation
= (resolved_plt
->output_section
->vma
3676 + resolved_plt
->output_offset
+ plt_offset
);
3681 if (h
->root
.root
.string
)
3682 name
= h
->root
.root
.string
;
3684 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3686 (*_bfd_error_handler
)
3687 (_("%B: relocation %s against STT_GNU_IFUNC "
3688 "symbol `%s' isn't handled by %s"), input_bfd
,
3689 x86_64_elf_howto_table
[r_type
].name
,
3690 name
, __FUNCTION__
);
3691 bfd_set_error (bfd_error_bad_value
);
3700 if (ABI_64_P (output_bfd
))
3704 if (rel
->r_addend
!= 0)
3706 if (h
->root
.root
.string
)
3707 name
= h
->root
.root
.string
;
3709 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3711 (*_bfd_error_handler
)
3712 (_("%B: relocation %s against STT_GNU_IFUNC "
3713 "symbol `%s' has non-zero addend: %d"),
3714 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3715 name
, rel
->r_addend
);
3716 bfd_set_error (bfd_error_bad_value
);
3720 /* Generate dynamic relcoation only when there is a
3721 non-GOT reference in a shared object. */
3722 if (info
->shared
&& h
->non_got_ref
)
3724 Elf_Internal_Rela outrel
;
3727 /* Need a dynamic relocation to get the real function
3729 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3733 if (outrel
.r_offset
== (bfd_vma
) -1
3734 || outrel
.r_offset
== (bfd_vma
) -2)
3737 outrel
.r_offset
+= (input_section
->output_section
->vma
3738 + input_section
->output_offset
);
3740 if (h
->dynindx
== -1
3742 || info
->executable
)
3744 /* This symbol is resolved locally. */
3745 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3746 outrel
.r_addend
= (h
->root
.u
.def
.value
3747 + h
->root
.u
.def
.section
->output_section
->vma
3748 + h
->root
.u
.def
.section
->output_offset
);
3752 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3753 outrel
.r_addend
= 0;
3756 sreloc
= htab
->elf
.irelifunc
;
3757 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3759 /* If this reloc is against an external symbol, we
3760 do not want to fiddle with the addend. Otherwise,
3761 we need to include the symbol value so that it
3762 becomes an addend for the dynamic reloc. For an
3763 internal symbol, we have updated addend. */
3768 case R_X86_64_PC32_BND
:
3770 case R_X86_64_PLT32
:
3771 case R_X86_64_PLT32_BND
:
3774 case R_X86_64_GOTPCREL
:
3775 case R_X86_64_GOTPCREL64
:
3776 base_got
= htab
->elf
.sgot
;
3777 off
= h
->got
.offset
;
3779 if (base_got
== NULL
)
3782 if (off
== (bfd_vma
) -1)
3784 /* We can't use h->got.offset here to save state, or
3785 even just remember the offset, as finish_dynamic_symbol
3786 would use that as offset into .got. */
3788 if (htab
->elf
.splt
!= NULL
)
3790 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3791 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3792 base_got
= htab
->elf
.sgotplt
;
3796 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3797 off
= plt_index
* GOT_ENTRY_SIZE
;
3798 base_got
= htab
->elf
.igotplt
;
3801 if (h
->dynindx
== -1
3805 /* This references the local defitionion. We must
3806 initialize this entry in the global offset table.
3807 Since the offset must always be a multiple of 8,
3808 we use the least significant bit to record
3809 whether we have initialized it already.
3811 When doing a dynamic link, we create a .rela.got
3812 relocation entry to initialize the value. This
3813 is done in the finish_dynamic_symbol routine. */
3818 bfd_put_64 (output_bfd
, relocation
,
3819 base_got
->contents
+ off
);
3820 /* Note that this is harmless for the GOTPLT64
3821 case, as -1 | 1 still is -1. */
3827 relocation
= (base_got
->output_section
->vma
3828 + base_got
->output_offset
+ off
);
3834 /* When generating a shared object, the relocations handled here are
3835 copied into the output file to be resolved at run time. */
3838 case R_X86_64_GOT32
:
3839 case R_X86_64_GOT64
:
3840 /* Relocation is to the entry for this symbol in the global
3842 case R_X86_64_GOTPCREL
:
3843 case R_X86_64_GOTPCREL64
:
3844 /* Use global offset table entry as symbol value. */
3845 case R_X86_64_GOTPLT64
:
3846 /* This is obsolete and treated the the same as GOT64. */
3847 base_got
= htab
->elf
.sgot
;
3849 if (htab
->elf
.sgot
== NULL
)
3856 off
= h
->got
.offset
;
3858 && h
->plt
.offset
!= (bfd_vma
)-1
3859 && off
== (bfd_vma
)-1)
3861 /* We can't use h->got.offset here to save
3862 state, or even just remember the offset, as
3863 finish_dynamic_symbol would use that as offset into
3865 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3866 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3867 base_got
= htab
->elf
.sgotplt
;
3870 dyn
= htab
->elf
.dynamic_sections_created
;
3872 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3874 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3875 || (ELF_ST_VISIBILITY (h
->other
)
3876 && h
->root
.type
== bfd_link_hash_undefweak
))
3878 /* This is actually a static link, or it is a -Bsymbolic
3879 link and the symbol is defined locally, or the symbol
3880 was forced to be local because of a version file. We
3881 must initialize this entry in the global offset table.
3882 Since the offset must always be a multiple of 8, we
3883 use the least significant bit to record whether we
3884 have initialized it already.
3886 When doing a dynamic link, we create a .rela.got
3887 relocation entry to initialize the value. This is
3888 done in the finish_dynamic_symbol routine. */
3893 bfd_put_64 (output_bfd
, relocation
,
3894 base_got
->contents
+ off
);
3895 /* Note that this is harmless for the GOTPLT64 case,
3896 as -1 | 1 still is -1. */
3901 unresolved_reloc
= FALSE
;
3905 if (local_got_offsets
== NULL
)
3908 off
= local_got_offsets
[r_symndx
];
3910 /* The offset must always be a multiple of 8. We use
3911 the least significant bit to record whether we have
3912 already generated the necessary reloc. */
3917 bfd_put_64 (output_bfd
, relocation
,
3918 base_got
->contents
+ off
);
3923 Elf_Internal_Rela outrel
;
3925 /* We need to generate a R_X86_64_RELATIVE reloc
3926 for the dynamic linker. */
3927 s
= htab
->elf
.srelgot
;
3931 outrel
.r_offset
= (base_got
->output_section
->vma
3932 + base_got
->output_offset
3934 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3935 outrel
.r_addend
= relocation
;
3936 elf_append_rela (output_bfd
, s
, &outrel
);
3939 local_got_offsets
[r_symndx
] |= 1;
3943 if (off
>= (bfd_vma
) -2)
3946 relocation
= base_got
->output_section
->vma
3947 + base_got
->output_offset
+ off
;
3948 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3949 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3950 - htab
->elf
.sgotplt
->output_offset
;
3954 case R_X86_64_GOTOFF64
:
3955 /* Relocation is relative to the start of the global offset
3958 /* Check to make sure it isn't a protected function or data
3959 symbol for shared library since it may not be local when
3960 used as function address or with copy relocation. We also
3961 need to make sure that a symbol is referenced locally. */
3962 if (info
->shared
&& h
)
3964 if (!h
->def_regular
)
3968 switch (ELF_ST_VISIBILITY (h
->other
))
3971 v
= _("hidden symbol");
3974 v
= _("internal symbol");
3977 v
= _("protected symbol");
3984 (*_bfd_error_handler
)
3985 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
3986 input_bfd
, v
, h
->root
.root
.string
);
3987 bfd_set_error (bfd_error_bad_value
);
3990 else if (!info
->executable
3991 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
3992 && (h
->type
== STT_FUNC
3993 || h
->type
== STT_OBJECT
)
3994 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3996 (*_bfd_error_handler
)
3997 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
3999 h
->type
== STT_FUNC
? "function" : "data",
4000 h
->root
.root
.string
);
4001 bfd_set_error (bfd_error_bad_value
);
4006 /* Note that sgot is not involved in this
4007 calculation. We always want the start of .got.plt. If we
4008 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4009 permitted by the ABI, we might have to change this
4011 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4012 + htab
->elf
.sgotplt
->output_offset
;
4015 case R_X86_64_GOTPC32
:
4016 case R_X86_64_GOTPC64
:
4017 /* Use global offset table as symbol value. */
4018 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4019 + htab
->elf
.sgotplt
->output_offset
;
4020 unresolved_reloc
= FALSE
;
4023 case R_X86_64_PLTOFF64
:
4024 /* Relocation is PLT entry relative to GOT. For local
4025 symbols it's the symbol itself relative to GOT. */
4027 /* See PLT32 handling. */
4028 && h
->plt
.offset
!= (bfd_vma
) -1
4029 && htab
->elf
.splt
!= NULL
)
4031 if (htab
->plt_bnd
!= NULL
)
4033 resolved_plt
= htab
->plt_bnd
;
4034 plt_offset
= eh
->plt_bnd
.offset
;
4038 resolved_plt
= htab
->elf
.splt
;
4039 plt_offset
= h
->plt
.offset
;
4042 relocation
= (resolved_plt
->output_section
->vma
4043 + resolved_plt
->output_offset
4045 unresolved_reloc
= FALSE
;
4048 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4049 + htab
->elf
.sgotplt
->output_offset
;
4052 case R_X86_64_PLT32
:
4053 case R_X86_64_PLT32_BND
:
4054 /* Relocation is to the entry for this symbol in the
4055 procedure linkage table. */
4057 /* Resolve a PLT32 reloc against a local symbol directly,
4058 without using the procedure linkage table. */
4062 if ((h
->plt
.offset
== (bfd_vma
) -1
4063 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4064 || htab
->elf
.splt
== NULL
)
4066 /* We didn't make a PLT entry for this symbol. This
4067 happens when statically linking PIC code, or when
4068 using -Bsymbolic. */
4072 if (h
->plt
.offset
!= (bfd_vma
) -1)
4074 if (htab
->plt_bnd
!= NULL
)
4076 resolved_plt
= htab
->plt_bnd
;
4077 plt_offset
= eh
->plt_bnd
.offset
;
4081 resolved_plt
= htab
->elf
.splt
;
4082 plt_offset
= h
->plt
.offset
;
4087 /* Use the GOT PLT. */
4088 resolved_plt
= htab
->plt_got
;
4089 plt_offset
= eh
->plt_got
.offset
;
4092 relocation
= (resolved_plt
->output_section
->vma
4093 + resolved_plt
->output_offset
4095 unresolved_reloc
= FALSE
;
4098 case R_X86_64_SIZE32
:
4099 case R_X86_64_SIZE64
:
4100 /* Set to symbol size. */
4101 relocation
= st_size
;
4107 case R_X86_64_PC32_BND
:
4108 /* Don't complain about -fPIC if the symbol is undefined when
4109 building executable. */
4111 && (input_section
->flags
& SEC_ALLOC
) != 0
4112 && (input_section
->flags
& SEC_READONLY
) != 0
4114 && !(info
->executable
4115 && h
->root
.type
== bfd_link_hash_undefined
))
4117 bfd_boolean fail
= FALSE
;
4119 = ((r_type
== R_X86_64_PC32
4120 || r_type
== R_X86_64_PC32_BND
)
4121 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4123 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4125 /* Symbol is referenced locally. Make sure it is
4126 defined locally or for a branch. */
4127 fail
= !h
->def_regular
&& !branch
;
4129 else if (!(info
->executable
4130 && (h
->needs_copy
|| eh
->needs_copy
)))
4132 /* Symbol doesn't need copy reloc and isn't referenced
4133 locally. We only allow branch to symbol with
4134 non-default visibility. */
4136 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4143 const char *pic
= "";
4145 switch (ELF_ST_VISIBILITY (h
->other
))
4148 v
= _("hidden symbol");
4151 v
= _("internal symbol");
4154 v
= _("protected symbol");
4158 pic
= _("; recompile with -fPIC");
4163 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4165 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4167 (*_bfd_error_handler
) (fmt
, input_bfd
,
4168 x86_64_elf_howto_table
[r_type
].name
,
4169 v
, h
->root
.root
.string
, pic
);
4170 bfd_set_error (bfd_error_bad_value
);
4181 /* FIXME: The ABI says the linker should make sure the value is
4182 the same when it's zeroextended to 64 bit. */
4185 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4188 /* Don't copy a pc-relative relocation into the output file
4189 if the symbol needs copy reloc or the symbol is undefined
4190 when building executable. */
4192 && !(info
->executable
4196 || h
->root
.type
== bfd_link_hash_undefined
)
4197 && IS_X86_64_PCREL_TYPE (r_type
))
4199 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4200 || h
->root
.type
!= bfd_link_hash_undefweak
)
4201 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4202 && r_type
!= R_X86_64_SIZE32
4203 && r_type
!= R_X86_64_SIZE64
)
4204 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4205 || (ELIMINATE_COPY_RELOCS
4212 || h
->root
.type
== bfd_link_hash_undefweak
4213 || h
->root
.type
== bfd_link_hash_undefined
)))
4215 Elf_Internal_Rela outrel
;
4216 bfd_boolean skip
, relocate
;
4219 /* When generating a shared object, these relocations
4220 are copied into the output file to be resolved at run
4226 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4228 if (outrel
.r_offset
== (bfd_vma
) -1)
4230 else if (outrel
.r_offset
== (bfd_vma
) -2)
4231 skip
= TRUE
, relocate
= TRUE
;
4233 outrel
.r_offset
+= (input_section
->output_section
->vma
4234 + input_section
->output_offset
);
4237 memset (&outrel
, 0, sizeof outrel
);
4239 /* h->dynindx may be -1 if this symbol was marked to
4243 && (IS_X86_64_PCREL_TYPE (r_type
)
4245 || ! SYMBOLIC_BIND (info
, h
)
4246 || ! h
->def_regular
))
4248 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4249 outrel
.r_addend
= rel
->r_addend
;
4253 /* This symbol is local, or marked to become local. */
4254 if (r_type
== htab
->pointer_r_type
)
4257 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4258 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4260 else if (r_type
== R_X86_64_64
4261 && !ABI_64_P (output_bfd
))
4264 outrel
.r_info
= htab
->r_info (0,
4265 R_X86_64_RELATIVE64
);
4266 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4267 /* Check addend overflow. */
4268 if ((outrel
.r_addend
& 0x80000000)
4269 != (rel
->r_addend
& 0x80000000))
4272 int addend
= rel
->r_addend
;
4273 if (h
&& h
->root
.root
.string
)
4274 name
= h
->root
.root
.string
;
4276 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4279 (*_bfd_error_handler
)
4280 (_("%B: addend -0x%x in relocation %s against "
4281 "symbol `%s' at 0x%lx in section `%A' is "
4283 input_bfd
, input_section
, addend
,
4284 x86_64_elf_howto_table
[r_type
].name
,
4285 name
, (unsigned long) rel
->r_offset
);
4287 (*_bfd_error_handler
)
4288 (_("%B: addend 0x%x in relocation %s against "
4289 "symbol `%s' at 0x%lx in section `%A' is "
4291 input_bfd
, input_section
, addend
,
4292 x86_64_elf_howto_table
[r_type
].name
,
4293 name
, (unsigned long) rel
->r_offset
);
4294 bfd_set_error (bfd_error_bad_value
);
4302 if (bfd_is_abs_section (sec
))
4304 else if (sec
== NULL
|| sec
->owner
== NULL
)
4306 bfd_set_error (bfd_error_bad_value
);
4313 /* We are turning this relocation into one
4314 against a section symbol. It would be
4315 proper to subtract the symbol's value,
4316 osec->vma, from the emitted reloc addend,
4317 but ld.so expects buggy relocs. */
4318 osec
= sec
->output_section
;
4319 sindx
= elf_section_data (osec
)->dynindx
;
4322 asection
*oi
= htab
->elf
.text_index_section
;
4323 sindx
= elf_section_data (oi
)->dynindx
;
4325 BFD_ASSERT (sindx
!= 0);
4328 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4329 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4333 sreloc
= elf_section_data (input_section
)->sreloc
;
4335 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4337 r
= bfd_reloc_notsupported
;
4338 goto check_relocation_error
;
4341 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4343 /* If this reloc is against an external symbol, we do
4344 not want to fiddle with the addend. Otherwise, we
4345 need to include the symbol value so that it becomes
4346 an addend for the dynamic reloc. */
4353 case R_X86_64_TLSGD
:
4354 case R_X86_64_GOTPC32_TLSDESC
:
4355 case R_X86_64_TLSDESC_CALL
:
4356 case R_X86_64_GOTTPOFF
:
4357 tls_type
= GOT_UNKNOWN
;
4358 if (h
== NULL
&& local_got_offsets
)
4359 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4361 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4363 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4364 input_section
, contents
,
4365 symtab_hdr
, sym_hashes
,
4366 &r_type
, tls_type
, rel
,
4367 relend
, h
, r_symndx
))
4370 if (r_type
== R_X86_64_TPOFF32
)
4372 bfd_vma roff
= rel
->r_offset
;
4374 BFD_ASSERT (! unresolved_reloc
);
4376 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4378 /* GD->LE transition. For 64bit, change
4379 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4380 .word 0x6666; rex64; call __tls_get_addr
4383 leaq foo@tpoff(%rax), %rax
4385 leaq foo@tlsgd(%rip), %rdi
4386 .word 0x6666; rex64; call __tls_get_addr
4389 leaq foo@tpoff(%rax), %rax
4390 For largepic, change:
4391 leaq foo@tlsgd(%rip), %rdi
4392 movabsq $__tls_get_addr@pltoff, %rax
4397 leaq foo@tpoff(%rax), %rax
4398 nopw 0x0(%rax,%rax,1) */
4400 if (ABI_64_P (output_bfd
)
4401 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4403 memcpy (contents
+ roff
- 3,
4404 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4405 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4408 else if (ABI_64_P (output_bfd
))
4409 memcpy (contents
+ roff
- 4,
4410 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4413 memcpy (contents
+ roff
- 3,
4414 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4416 bfd_put_32 (output_bfd
,
4417 elf_x86_64_tpoff (info
, relocation
),
4418 contents
+ roff
+ 8 + largepic
);
4419 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4423 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4425 /* GDesc -> LE transition.
4426 It's originally something like:
4427 leaq x@tlsdesc(%rip), %rax
4430 movl $x@tpoff, %rax. */
4432 unsigned int val
, type
;
4434 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4435 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4436 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4437 contents
+ roff
- 3);
4438 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4439 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4440 contents
+ roff
- 1);
4441 bfd_put_32 (output_bfd
,
4442 elf_x86_64_tpoff (info
, relocation
),
4446 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4448 /* GDesc -> LE transition.
4453 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4454 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4457 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4459 /* IE->LE transition:
4460 For 64bit, originally it can be one of:
4461 movq foo@gottpoff(%rip), %reg
4462 addq foo@gottpoff(%rip), %reg
4465 leaq foo(%reg), %reg
4467 For 32bit, originally it can be one of:
4468 movq foo@gottpoff(%rip), %reg
4469 addl foo@gottpoff(%rip), %reg
4472 leal foo(%reg), %reg
4475 unsigned int val
, type
, reg
;
4478 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4481 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4482 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4488 bfd_put_8 (output_bfd
, 0x49,
4489 contents
+ roff
- 3);
4490 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4491 bfd_put_8 (output_bfd
, 0x41,
4492 contents
+ roff
- 3);
4493 bfd_put_8 (output_bfd
, 0xc7,
4494 contents
+ roff
- 2);
4495 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4496 contents
+ roff
- 1);
4500 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4503 bfd_put_8 (output_bfd
, 0x49,
4504 contents
+ roff
- 3);
4505 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4506 bfd_put_8 (output_bfd
, 0x41,
4507 contents
+ roff
- 3);
4508 bfd_put_8 (output_bfd
, 0x81,
4509 contents
+ roff
- 2);
4510 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4511 contents
+ roff
- 1);
4515 /* addq/addl -> leaq/leal */
4517 bfd_put_8 (output_bfd
, 0x4d,
4518 contents
+ roff
- 3);
4519 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4520 bfd_put_8 (output_bfd
, 0x45,
4521 contents
+ roff
- 3);
4522 bfd_put_8 (output_bfd
, 0x8d,
4523 contents
+ roff
- 2);
4524 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4525 contents
+ roff
- 1);
4527 bfd_put_32 (output_bfd
,
4528 elf_x86_64_tpoff (info
, relocation
),
4536 if (htab
->elf
.sgot
== NULL
)
4541 off
= h
->got
.offset
;
4542 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4546 if (local_got_offsets
== NULL
)
4549 off
= local_got_offsets
[r_symndx
];
4550 offplt
= local_tlsdesc_gotents
[r_symndx
];
4557 Elf_Internal_Rela outrel
;
4561 if (htab
->elf
.srelgot
== NULL
)
4564 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4566 if (GOT_TLS_GDESC_P (tls_type
))
4568 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4569 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4570 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4571 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4572 + htab
->elf
.sgotplt
->output_offset
4574 + htab
->sgotplt_jump_table_size
);
4575 sreloc
= htab
->elf
.srelplt
;
4577 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4579 outrel
.r_addend
= 0;
4580 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4583 sreloc
= htab
->elf
.srelgot
;
4585 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4586 + htab
->elf
.sgot
->output_offset
+ off
);
4588 if (GOT_TLS_GD_P (tls_type
))
4589 dr_type
= R_X86_64_DTPMOD64
;
4590 else if (GOT_TLS_GDESC_P (tls_type
))
4593 dr_type
= R_X86_64_TPOFF64
;
4595 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4596 outrel
.r_addend
= 0;
4597 if ((dr_type
== R_X86_64_TPOFF64
4598 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4599 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4600 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4602 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4604 if (GOT_TLS_GD_P (tls_type
))
4608 BFD_ASSERT (! unresolved_reloc
);
4609 bfd_put_64 (output_bfd
,
4610 relocation
- elf_x86_64_dtpoff_base (info
),
4611 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4615 bfd_put_64 (output_bfd
, 0,
4616 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4617 outrel
.r_info
= htab
->r_info (indx
,
4619 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4620 elf_append_rela (output_bfd
, sreloc
,
4629 local_got_offsets
[r_symndx
] |= 1;
4632 if (off
>= (bfd_vma
) -2
4633 && ! GOT_TLS_GDESC_P (tls_type
))
4635 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4637 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4638 || r_type
== R_X86_64_TLSDESC_CALL
)
4639 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4640 + htab
->elf
.sgotplt
->output_offset
4641 + offplt
+ htab
->sgotplt_jump_table_size
;
4643 relocation
= htab
->elf
.sgot
->output_section
->vma
4644 + htab
->elf
.sgot
->output_offset
+ off
;
4645 unresolved_reloc
= FALSE
;
4649 bfd_vma roff
= rel
->r_offset
;
4651 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4653 /* GD->IE transition. For 64bit, change
4654 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4655 .word 0x6666; rex64; call __tls_get_addr@plt
4658 addq foo@gottpoff(%rip), %rax
4660 leaq foo@tlsgd(%rip), %rdi
4661 .word 0x6666; rex64; call __tls_get_addr@plt
4664 addq foo@gottpoff(%rip), %rax
4665 For largepic, change:
4666 leaq foo@tlsgd(%rip), %rdi
4667 movabsq $__tls_get_addr@pltoff, %rax
4672 addq foo@gottpoff(%rax), %rax
4673 nopw 0x0(%rax,%rax,1) */
4675 if (ABI_64_P (output_bfd
)
4676 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4678 memcpy (contents
+ roff
- 3,
4679 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4680 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4683 else if (ABI_64_P (output_bfd
))
4684 memcpy (contents
+ roff
- 4,
4685 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4688 memcpy (contents
+ roff
- 3,
4689 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4692 relocation
= (htab
->elf
.sgot
->output_section
->vma
4693 + htab
->elf
.sgot
->output_offset
+ off
4696 - input_section
->output_section
->vma
4697 - input_section
->output_offset
4699 bfd_put_32 (output_bfd
, relocation
,
4700 contents
+ roff
+ 8 + largepic
);
4701 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4705 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4707 /* GDesc -> IE transition.
4708 It's originally something like:
4709 leaq x@tlsdesc(%rip), %rax
4712 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4714 /* Now modify the instruction as appropriate. To
4715 turn a leaq into a movq in the form we use it, it
4716 suffices to change the second byte from 0x8d to
4718 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4720 bfd_put_32 (output_bfd
,
4721 htab
->elf
.sgot
->output_section
->vma
4722 + htab
->elf
.sgot
->output_offset
+ off
4724 - input_section
->output_section
->vma
4725 - input_section
->output_offset
4730 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4732 /* GDesc -> IE transition.
4739 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4740 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4748 case R_X86_64_TLSLD
:
4749 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4750 input_section
, contents
,
4751 symtab_hdr
, sym_hashes
,
4752 &r_type
, GOT_UNKNOWN
,
4753 rel
, relend
, h
, r_symndx
))
4756 if (r_type
!= R_X86_64_TLSLD
)
4758 /* LD->LE transition:
4759 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4760 For 64bit, we change it into:
4761 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4762 For 32bit, we change it into:
4763 nopl 0x0(%rax); movl %fs:0, %eax.
4764 For largepic, change:
4765 leaq foo@tlsgd(%rip), %rdi
4766 movabsq $__tls_get_addr@pltoff, %rax
4770 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4773 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4774 if (ABI_64_P (output_bfd
)
4775 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4776 memcpy (contents
+ rel
->r_offset
- 3,
4777 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4778 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4779 else if (ABI_64_P (output_bfd
))
4780 memcpy (contents
+ rel
->r_offset
- 3,
4781 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4783 memcpy (contents
+ rel
->r_offset
- 3,
4784 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4785 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4790 if (htab
->elf
.sgot
== NULL
)
4793 off
= htab
->tls_ld_got
.offset
;
4798 Elf_Internal_Rela outrel
;
4800 if (htab
->elf
.srelgot
== NULL
)
4803 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4804 + htab
->elf
.sgot
->output_offset
+ off
);
4806 bfd_put_64 (output_bfd
, 0,
4807 htab
->elf
.sgot
->contents
+ off
);
4808 bfd_put_64 (output_bfd
, 0,
4809 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4810 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4811 outrel
.r_addend
= 0;
4812 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4814 htab
->tls_ld_got
.offset
|= 1;
4816 relocation
= htab
->elf
.sgot
->output_section
->vma
4817 + htab
->elf
.sgot
->output_offset
+ off
;
4818 unresolved_reloc
= FALSE
;
4821 case R_X86_64_DTPOFF32
:
4822 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4823 relocation
-= elf_x86_64_dtpoff_base (info
);
4825 relocation
= elf_x86_64_tpoff (info
, relocation
);
4828 case R_X86_64_TPOFF32
:
4829 case R_X86_64_TPOFF64
:
4830 BFD_ASSERT (info
->executable
);
4831 relocation
= elf_x86_64_tpoff (info
, relocation
);
4834 case R_X86_64_DTPOFF64
:
4835 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4836 relocation
-= elf_x86_64_dtpoff_base (info
);
4843 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4844 because such sections are not SEC_ALLOC and thus ld.so will
4845 not process them. */
4846 if (unresolved_reloc
4847 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4849 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4850 rel
->r_offset
) != (bfd_vma
) -1)
4852 (*_bfd_error_handler
)
4853 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4856 (long) rel
->r_offset
,
4858 h
->root
.root
.string
);
4863 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4864 contents
, rel
->r_offset
,
4865 relocation
, rel
->r_addend
);
4867 check_relocation_error
:
4868 if (r
!= bfd_reloc_ok
)
4873 name
= h
->root
.root
.string
;
4876 name
= bfd_elf_string_from_elf_section (input_bfd
,
4877 symtab_hdr
->sh_link
,
4882 name
= bfd_section_name (input_bfd
, sec
);
4885 if (r
== bfd_reloc_overflow
)
4887 if (! ((*info
->callbacks
->reloc_overflow
)
4888 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4889 (bfd_vma
) 0, input_bfd
, input_section
,
4895 (*_bfd_error_handler
)
4896 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4897 input_bfd
, input_section
,
4898 (long) rel
->r_offset
, name
, (int) r
);
4907 /* Finish up dynamic symbol handling. We set the contents of various
4908 dynamic sections here. */
4911 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4912 struct bfd_link_info
*info
,
4913 struct elf_link_hash_entry
*h
,
4914 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4916 struct elf_x86_64_link_hash_table
*htab
;
4917 const struct elf_x86_64_backend_data
*abed
;
4918 bfd_boolean use_plt_bnd
;
4919 struct elf_x86_64_link_hash_entry
*eh
;
4921 htab
= elf_x86_64_hash_table (info
);
4925 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4926 section only if there is .plt section. */
4927 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
4929 ? &elf_x86_64_bnd_arch_bed
4930 : get_elf_x86_64_backend_data (output_bfd
));
4932 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4934 if (h
->plt
.offset
!= (bfd_vma
) -1)
4937 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
4938 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
4939 Elf_Internal_Rela rela
;
4941 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4942 const struct elf_backend_data
*bed
;
4943 bfd_vma plt_got_pcrel_offset
;
4945 /* When building a static executable, use .iplt, .igot.plt and
4946 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4947 if (htab
->elf
.splt
!= NULL
)
4949 plt
= htab
->elf
.splt
;
4950 gotplt
= htab
->elf
.sgotplt
;
4951 relplt
= htab
->elf
.srelplt
;
4955 plt
= htab
->elf
.iplt
;
4956 gotplt
= htab
->elf
.igotplt
;
4957 relplt
= htab
->elf
.irelplt
;
4960 /* This symbol has an entry in the procedure linkage table. Set
4962 if ((h
->dynindx
== -1
4963 && !((h
->forced_local
|| info
->executable
)
4965 && h
->type
== STT_GNU_IFUNC
))
4971 /* Get the index in the procedure linkage table which
4972 corresponds to this symbol. This is the index of this symbol
4973 in all the symbols for which we are making plt entries. The
4974 first entry in the procedure linkage table is reserved.
4976 Get the offset into the .got table of the entry that
4977 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4978 bytes. The first three are reserved for the dynamic linker.
4980 For static executables, we don't reserve anything. */
4982 if (plt
== htab
->elf
.splt
)
4984 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4985 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4989 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4990 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4993 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
4994 plt_plt_offset
= abed
->plt_plt_offset
;
4995 plt_got_insn_size
= abed
->plt_got_insn_size
;
4996 plt_got_offset
= abed
->plt_got_offset
;
4999 /* Use the second PLT with BND relocations. */
5000 const bfd_byte
*plt_entry
, *plt2_entry
;
5002 if (eh
->has_bnd_reloc
)
5004 plt_entry
= elf_x86_64_bnd_plt_entry
;
5005 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5009 plt_entry
= elf_x86_64_legacy_plt_entry
;
5010 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5012 /* Subtract 1 since there is no BND prefix. */
5013 plt_plt_insn_end
-= 1;
5014 plt_plt_offset
-= 1;
5015 plt_got_insn_size
-= 1;
5016 plt_got_offset
-= 1;
5019 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5020 == sizeof (elf_x86_64_legacy_plt_entry
));
5022 /* Fill in the entry in the procedure linkage table. */
5023 memcpy (plt
->contents
+ h
->plt
.offset
,
5024 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5025 /* Fill in the entry in the second PLT. */
5026 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5027 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5029 resolved_plt
= htab
->plt_bnd
;
5030 plt_offset
= eh
->plt_bnd
.offset
;
5034 /* Fill in the entry in the procedure linkage table. */
5035 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5036 abed
->plt_entry_size
);
5039 plt_offset
= h
->plt
.offset
;
5042 /* Insert the relocation positions of the plt section. */
5044 /* Put offset the PC-relative instruction referring to the GOT entry,
5045 subtracting the size of that instruction. */
5046 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5047 + gotplt
->output_offset
5049 - resolved_plt
->output_section
->vma
5050 - resolved_plt
->output_offset
5052 - plt_got_insn_size
);
5054 /* Check PC-relative offset overflow in PLT entry. */
5055 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5056 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5057 output_bfd
, h
->root
.root
.string
);
5059 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5060 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5062 /* Fill in the entry in the global offset table, initially this
5063 points to the second part of the PLT entry. */
5064 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5065 + plt
->output_offset
5066 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
5067 gotplt
->contents
+ got_offset
);
5069 /* Fill in the entry in the .rela.plt section. */
5070 rela
.r_offset
= (gotplt
->output_section
->vma
5071 + gotplt
->output_offset
5073 if (h
->dynindx
== -1
5074 || ((info
->executable
5075 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5077 && h
->type
== STT_GNU_IFUNC
))
5079 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5080 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5081 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5082 rela
.r_addend
= (h
->root
.u
.def
.value
5083 + h
->root
.u
.def
.section
->output_section
->vma
5084 + h
->root
.u
.def
.section
->output_offset
);
5085 /* R_X86_64_IRELATIVE comes last. */
5086 plt_index
= htab
->next_irelative_index
--;
5090 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5092 plt_index
= htab
->next_jump_slot_index
++;
5095 /* Don't fill PLT entry for static executables. */
5096 if (plt
== htab
->elf
.splt
)
5098 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5100 /* Put relocation index. */
5101 bfd_put_32 (output_bfd
, plt_index
,
5102 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
5104 /* Put offset for jmp .PLT0 and check for overflow. We don't
5105 check relocation index for overflow since branch displacement
5106 will overflow first. */
5107 if (plt0_offset
> 0x80000000)
5108 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5109 output_bfd
, h
->root
.root
.string
);
5110 bfd_put_32 (output_bfd
, - plt0_offset
,
5111 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5114 bed
= get_elf_backend_data (output_bfd
);
5115 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5116 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5118 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5120 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5121 asection
*plt
, *got
;
5122 bfd_boolean got_after_plt
;
5123 int32_t got_pcrel_offset
;
5124 const bfd_byte
*got_plt_entry
;
5126 /* Set the entry in the GOT procedure linkage table. */
5127 plt
= htab
->plt_got
;
5128 got
= htab
->elf
.sgot
;
5129 got_offset
= h
->got
.offset
;
5131 if (got_offset
== (bfd_vma
) -1
5132 || h
->type
== STT_GNU_IFUNC
5137 /* Use the second PLT entry template for the GOT PLT since they
5138 are the identical. */
5139 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5140 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5141 if (eh
->has_bnd_reloc
)
5142 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5145 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5147 /* Subtract 1 since there is no BND prefix. */
5148 plt_got_insn_size
-= 1;
5149 plt_got_offset
-= 1;
5152 /* Fill in the entry in the GOT procedure linkage table. */
5153 plt_offset
= eh
->plt_got
.offset
;
5154 memcpy (plt
->contents
+ plt_offset
,
5155 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5157 /* Put offset the PC-relative instruction referring to the GOT
5158 entry, subtracting the size of that instruction. */
5159 got_pcrel_offset
= (got
->output_section
->vma
5160 + got
->output_offset
5162 - plt
->output_section
->vma
5163 - plt
->output_offset
5165 - plt_got_insn_size
);
5167 /* Check PC-relative offset overflow in GOT PLT entry. */
5168 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5169 if ((got_after_plt
&& got_pcrel_offset
< 0)
5170 || (!got_after_plt
&& got_pcrel_offset
> 0))
5171 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5172 output_bfd
, h
->root
.root
.string
);
5174 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5175 plt
->contents
+ plt_offset
+ plt_got_offset
);
5179 && (h
->plt
.offset
!= (bfd_vma
) -1
5180 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5182 /* Mark the symbol as undefined, rather than as defined in
5183 the .plt section. Leave the value if there were any
5184 relocations where pointer equality matters (this is a clue
5185 for the dynamic linker, to make function pointer
5186 comparisons work between an application and shared
5187 library), otherwise set it to zero. If a function is only
5188 called from a binary, there is no need to slow down
5189 shared libraries because of that. */
5190 sym
->st_shndx
= SHN_UNDEF
;
5191 if (!h
->pointer_equality_needed
)
5195 if (h
->got
.offset
!= (bfd_vma
) -1
5196 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5197 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
5199 Elf_Internal_Rela rela
;
5201 /* This symbol has an entry in the global offset table. Set it
5203 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5206 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5207 + htab
->elf
.sgot
->output_offset
5208 + (h
->got
.offset
&~ (bfd_vma
) 1));
5210 /* If this is a static link, or it is a -Bsymbolic link and the
5211 symbol is defined locally or was forced to be local because
5212 of a version file, we just want to emit a RELATIVE reloc.
5213 The entry in the global offset table will already have been
5214 initialized in the relocate_section function. */
5216 && h
->type
== STT_GNU_IFUNC
)
5220 /* Generate R_X86_64_GLOB_DAT. */
5227 if (!h
->pointer_equality_needed
)
5230 /* For non-shared object, we can't use .got.plt, which
5231 contains the real function addres if we need pointer
5232 equality. We load the GOT entry with the PLT entry. */
5233 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5234 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5235 + plt
->output_offset
5237 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5241 else if (info
->shared
5242 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5244 if (!h
->def_regular
)
5246 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5247 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5248 rela
.r_addend
= (h
->root
.u
.def
.value
5249 + h
->root
.u
.def
.section
->output_section
->vma
5250 + h
->root
.u
.def
.section
->output_offset
);
5254 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5256 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5257 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5258 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5262 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5267 Elf_Internal_Rela rela
;
5269 /* This symbol needs a copy reloc. Set it up. */
5271 if (h
->dynindx
== -1
5272 || (h
->root
.type
!= bfd_link_hash_defined
5273 && h
->root
.type
!= bfd_link_hash_defweak
)
5274 || htab
->srelbss
== NULL
)
5277 rela
.r_offset
= (h
->root
.u
.def
.value
5278 + h
->root
.u
.def
.section
->output_section
->vma
5279 + h
->root
.u
.def
.section
->output_offset
);
5280 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5282 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5288 /* Finish up local dynamic symbol handling. We set the contents of
5289 various dynamic sections here. */
5292 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5294 struct elf_link_hash_entry
*h
5295 = (struct elf_link_hash_entry
*) *slot
;
5296 struct bfd_link_info
*info
5297 = (struct bfd_link_info
*) inf
;
5299 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5303 /* Used to decide how to sort relocs in an optimal manner for the
5304 dynamic linker, before writing them out. */
5306 static enum elf_reloc_type_class
5307 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5308 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5309 const Elf_Internal_Rela
*rela
)
5311 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5313 case R_X86_64_RELATIVE
:
5314 case R_X86_64_RELATIVE64
:
5315 return reloc_class_relative
;
5316 case R_X86_64_JUMP_SLOT
:
5317 return reloc_class_plt
;
5319 return reloc_class_copy
;
5321 return reloc_class_normal
;
5325 /* Finish up the dynamic sections. */
5328 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5329 struct bfd_link_info
*info
)
5331 struct elf_x86_64_link_hash_table
*htab
;
5334 const struct elf_x86_64_backend_data
*abed
;
5336 htab
= elf_x86_64_hash_table (info
);
5340 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5341 section only if there is .plt section. */
5342 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5343 ? &elf_x86_64_bnd_arch_bed
5344 : get_elf_x86_64_backend_data (output_bfd
));
5346 dynobj
= htab
->elf
.dynobj
;
5347 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5349 if (htab
->elf
.dynamic_sections_created
)
5351 bfd_byte
*dyncon
, *dynconend
;
5352 const struct elf_backend_data
*bed
;
5353 bfd_size_type sizeof_dyn
;
5355 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5358 bed
= get_elf_backend_data (dynobj
);
5359 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5360 dyncon
= sdyn
->contents
;
5361 dynconend
= sdyn
->contents
+ sdyn
->size
;
5362 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5364 Elf_Internal_Dyn dyn
;
5367 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5375 s
= htab
->elf
.sgotplt
;
5376 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5380 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5384 s
= htab
->elf
.srelplt
->output_section
;
5385 dyn
.d_un
.d_val
= s
->size
;
5389 /* The procedure linkage table relocs (DT_JMPREL) should
5390 not be included in the overall relocs (DT_RELA).
5391 Therefore, we override the DT_RELASZ entry here to
5392 make it not include the JMPREL relocs. Since the
5393 linker script arranges for .rela.plt to follow all
5394 other relocation sections, we don't have to worry
5395 about changing the DT_RELA entry. */
5396 if (htab
->elf
.srelplt
!= NULL
)
5398 s
= htab
->elf
.srelplt
->output_section
;
5399 dyn
.d_un
.d_val
-= s
->size
;
5403 case DT_TLSDESC_PLT
:
5405 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5406 + htab
->tlsdesc_plt
;
5409 case DT_TLSDESC_GOT
:
5411 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5412 + htab
->tlsdesc_got
;
5416 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5419 /* Fill in the special first entry in the procedure linkage table. */
5420 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5422 /* Fill in the first entry in the procedure linkage table. */
5423 memcpy (htab
->elf
.splt
->contents
,
5424 abed
->plt0_entry
, abed
->plt_entry_size
);
5425 /* Add offset for pushq GOT+8(%rip), since the instruction
5426 uses 6 bytes subtract this value. */
5427 bfd_put_32 (output_bfd
,
5428 (htab
->elf
.sgotplt
->output_section
->vma
5429 + htab
->elf
.sgotplt
->output_offset
5431 - htab
->elf
.splt
->output_section
->vma
5432 - htab
->elf
.splt
->output_offset
5434 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5435 /* Add offset for the PC-relative instruction accessing GOT+16,
5436 subtracting the offset to the end of that instruction. */
5437 bfd_put_32 (output_bfd
,
5438 (htab
->elf
.sgotplt
->output_section
->vma
5439 + htab
->elf
.sgotplt
->output_offset
5441 - htab
->elf
.splt
->output_section
->vma
5442 - htab
->elf
.splt
->output_offset
5443 - abed
->plt0_got2_insn_end
),
5444 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5446 elf_section_data (htab
->elf
.splt
->output_section
)
5447 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5449 if (htab
->tlsdesc_plt
)
5451 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5452 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5454 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5455 abed
->plt0_entry
, abed
->plt_entry_size
);
5457 /* Add offset for pushq GOT+8(%rip), since the
5458 instruction uses 6 bytes subtract this value. */
5459 bfd_put_32 (output_bfd
,
5460 (htab
->elf
.sgotplt
->output_section
->vma
5461 + htab
->elf
.sgotplt
->output_offset
5463 - htab
->elf
.splt
->output_section
->vma
5464 - htab
->elf
.splt
->output_offset
5467 htab
->elf
.splt
->contents
5468 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5469 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5470 where TGD stands for htab->tlsdesc_got, subtracting the offset
5471 to the end of that instruction. */
5472 bfd_put_32 (output_bfd
,
5473 (htab
->elf
.sgot
->output_section
->vma
5474 + htab
->elf
.sgot
->output_offset
5476 - htab
->elf
.splt
->output_section
->vma
5477 - htab
->elf
.splt
->output_offset
5479 - abed
->plt0_got2_insn_end
),
5480 htab
->elf
.splt
->contents
5481 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5486 if (htab
->plt_bnd
!= NULL
)
5487 elf_section_data (htab
->plt_bnd
->output_section
)
5488 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5490 if (htab
->elf
.sgotplt
)
5492 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5494 (*_bfd_error_handler
)
5495 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5499 /* Fill in the first three entries in the global offset table. */
5500 if (htab
->elf
.sgotplt
->size
> 0)
5502 /* Set the first entry in the global offset table to the address of
5503 the dynamic section. */
5505 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5507 bfd_put_64 (output_bfd
,
5508 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5509 htab
->elf
.sgotplt
->contents
);
5510 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5511 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5512 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5515 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5519 /* Adjust .eh_frame for .plt section. */
5520 if (htab
->plt_eh_frame
!= NULL
5521 && htab
->plt_eh_frame
->contents
!= NULL
)
5523 if (htab
->elf
.splt
!= NULL
5524 && htab
->elf
.splt
->size
!= 0
5525 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5526 && htab
->elf
.splt
->output_section
!= NULL
5527 && htab
->plt_eh_frame
->output_section
!= NULL
)
5529 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5530 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5531 + htab
->plt_eh_frame
->output_offset
5532 + PLT_FDE_START_OFFSET
;
5533 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5534 htab
->plt_eh_frame
->contents
5535 + PLT_FDE_START_OFFSET
);
5537 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5539 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5541 htab
->plt_eh_frame
->contents
))
5546 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5547 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5550 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5551 htab_traverse (htab
->loc_hash_table
,
5552 elf_x86_64_finish_local_dynamic_symbol
,
5558 /* Return an array of PLT entry symbol values. */
5561 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
5564 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5567 bfd_vma
*plt_sym_val
;
5569 bfd_byte
*plt_contents
;
5570 const struct elf_x86_64_backend_data
*bed
;
5571 Elf_Internal_Shdr
*hdr
;
5574 /* Get the .plt section contents. PLT passed down may point to the
5575 .plt.bnd section. Make sure that PLT always points to the .plt
5577 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5582 plt
= bfd_get_section_by_name (abfd
, ".plt");
5585 bed
= &elf_x86_64_bnd_arch_bed
;
5588 bed
= get_elf_x86_64_backend_data (abfd
);
5590 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5591 if (plt_contents
== NULL
)
5593 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5594 plt_contents
, 0, plt
->size
))
5597 free (plt_contents
);
5601 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5602 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5605 hdr
= &elf_section_data (relplt
)->this_hdr
;
5606 count
= relplt
->size
/ hdr
->sh_entsize
;
5608 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
5609 if (plt_sym_val
== NULL
)
5612 for (i
= 0; i
< count
; i
++)
5613 plt_sym_val
[i
] = -1;
5615 plt_offset
= bed
->plt_entry_size
;
5616 p
= relplt
->relocation
;
5617 for (i
= 0; i
< count
; i
++, p
++)
5621 /* Skip unknown relocation. */
5622 if (p
->howto
== NULL
)
5625 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5626 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5629 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
5630 + bed
->plt_reloc_offset
));
5631 if (reloc_index
>= count
)
5635 /* This is the index in .plt section. */
5636 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5637 /* Store VMA + the offset in .plt.bnd section. */
5638 plt_sym_val
[reloc_index
] =
5640 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
5643 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
5644 plt_offset
+= bed
->plt_entry_size
;
5647 free (plt_contents
);
5652 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5656 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5663 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
5664 as PLT if it exists. */
5665 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5667 plt
= bfd_get_section_by_name (abfd
, ".plt");
5668 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
5669 dynsymcount
, dynsyms
, ret
,
5671 elf_x86_64_get_plt_sym_val
);
5674 /* Handle an x86-64 specific section when reading an object file. This
5675 is called when elfcode.h finds a section with an unknown type. */
5678 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5679 const char *name
, int shindex
)
5681 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5684 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5690 /* Hook called by the linker routine which adds symbols from an object
5691 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5695 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5696 struct bfd_link_info
*info
,
5697 Elf_Internal_Sym
*sym
,
5698 const char **namep ATTRIBUTE_UNUSED
,
5699 flagword
*flagsp ATTRIBUTE_UNUSED
,
5705 switch (sym
->st_shndx
)
5707 case SHN_X86_64_LCOMMON
:
5708 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5711 lcomm
= bfd_make_section_with_flags (abfd
,
5715 | SEC_LINKER_CREATED
));
5718 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5721 *valp
= sym
->st_size
;
5725 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5726 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
5727 && (abfd
->flags
& DYNAMIC
) == 0
5728 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5729 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5735 /* Given a BFD section, try to locate the corresponding ELF section
5739 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5740 asection
*sec
, int *index_return
)
5742 if (sec
== &_bfd_elf_large_com_section
)
5744 *index_return
= SHN_X86_64_LCOMMON
;
5750 /* Process a symbol. */
5753 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5756 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5758 switch (elfsym
->internal_elf_sym
.st_shndx
)
5760 case SHN_X86_64_LCOMMON
:
5761 asym
->section
= &_bfd_elf_large_com_section
;
5762 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5763 /* Common symbol doesn't set BSF_GLOBAL. */
5764 asym
->flags
&= ~BSF_GLOBAL
;
5770 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5772 return (sym
->st_shndx
== SHN_COMMON
5773 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5777 elf_x86_64_common_section_index (asection
*sec
)
5779 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5782 return SHN_X86_64_LCOMMON
;
5786 elf_x86_64_common_section (asection
*sec
)
5788 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5789 return bfd_com_section_ptr
;
5791 return &_bfd_elf_large_com_section
;
5795 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5796 const Elf_Internal_Sym
*sym
,
5801 const asection
*oldsec
)
5803 /* A normal common symbol and a large common symbol result in a
5804 normal common symbol. We turn the large common symbol into a
5807 && h
->root
.type
== bfd_link_hash_common
5809 && bfd_is_com_section (*psec
)
5812 if (sym
->st_shndx
== SHN_COMMON
5813 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5815 h
->root
.u
.c
.p
->section
5816 = bfd_make_section_old_way (oldbfd
, "COMMON");
5817 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5819 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5820 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5821 *psec
= bfd_com_section_ptr
;
5828 elf_x86_64_additional_program_headers (bfd
*abfd
,
5829 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5834 /* Check to see if we need a large readonly segment. */
5835 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5836 if (s
&& (s
->flags
& SEC_LOAD
))
5839 /* Check to see if we need a large data segment. Since .lbss sections
5840 is placed right after the .bss section, there should be no need for
5841 a large data segment just because of .lbss. */
5842 s
= bfd_get_section_by_name (abfd
, ".ldata");
5843 if (s
&& (s
->flags
& SEC_LOAD
))
5849 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5852 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5854 if (h
->plt
.offset
!= (bfd_vma
) -1
5856 && !h
->pointer_equality_needed
)
5859 return _bfd_elf_hash_symbol (h
);
5862 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5865 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5866 const bfd_target
*output
)
5868 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5869 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5870 && _bfd_elf_relocs_compatible (input
, output
));
5873 static const struct bfd_elf_special_section
5874 elf_x86_64_special_sections
[]=
5876 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5877 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5878 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5879 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5880 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5881 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5882 { NULL
, 0, 0, 0, 0 }
5885 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5886 #define TARGET_LITTLE_NAME "elf64-x86-64"
5887 #define ELF_ARCH bfd_arch_i386
5888 #define ELF_TARGET_ID X86_64_ELF_DATA
5889 #define ELF_MACHINE_CODE EM_X86_64
5890 #define ELF_MAXPAGESIZE 0x200000
5891 #define ELF_MINPAGESIZE 0x1000
5892 #define ELF_COMMONPAGESIZE 0x1000
5894 #define elf_backend_can_gc_sections 1
5895 #define elf_backend_can_refcount 1
5896 #define elf_backend_want_got_plt 1
5897 #define elf_backend_plt_readonly 1
5898 #define elf_backend_want_plt_sym 0
5899 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5900 #define elf_backend_rela_normal 1
5901 #define elf_backend_plt_alignment 4
5902 #define elf_backend_extern_protected_data 1
5904 #define elf_info_to_howto elf_x86_64_info_to_howto
5906 #define bfd_elf64_bfd_link_hash_table_create \
5907 elf_x86_64_link_hash_table_create
5908 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5909 #define bfd_elf64_bfd_reloc_name_lookup \
5910 elf_x86_64_reloc_name_lookup
5912 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5913 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5914 #define elf_backend_check_relocs elf_x86_64_check_relocs
5915 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5916 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5917 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5918 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5919 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5920 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5921 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5922 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5924 #define elf_backend_write_core_note elf_x86_64_write_core_note
5926 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5927 #define elf_backend_relocate_section elf_x86_64_relocate_section
5928 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5929 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5930 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5931 #define elf_backend_object_p elf64_x86_64_elf_object_p
5932 #define bfd_elf64_mkobject elf_x86_64_mkobject
5933 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5935 #define elf_backend_section_from_shdr \
5936 elf_x86_64_section_from_shdr
5938 #define elf_backend_section_from_bfd_section \
5939 elf_x86_64_elf_section_from_bfd_section
5940 #define elf_backend_add_symbol_hook \
5941 elf_x86_64_add_symbol_hook
5942 #define elf_backend_symbol_processing \
5943 elf_x86_64_symbol_processing
5944 #define elf_backend_common_section_index \
5945 elf_x86_64_common_section_index
5946 #define elf_backend_common_section \
5947 elf_x86_64_common_section
5948 #define elf_backend_common_definition \
5949 elf_x86_64_common_definition
5950 #define elf_backend_merge_symbol \
5951 elf_x86_64_merge_symbol
5952 #define elf_backend_special_sections \
5953 elf_x86_64_special_sections
5954 #define elf_backend_additional_program_headers \
5955 elf_x86_64_additional_program_headers
5956 #define elf_backend_hash_symbol \
5957 elf_x86_64_hash_symbol
5959 #include "elf64-target.h"
5961 /* CloudABI support. */
5963 #undef TARGET_LITTLE_SYM
5964 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
5965 #undef TARGET_LITTLE_NAME
5966 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
5969 #define ELF_OSABI ELFOSABI_CLOUDABI
5972 #define elf64_bed elf64_x86_64_cloudabi_bed
5974 #include "elf64-target.h"
5976 /* FreeBSD support. */
5978 #undef TARGET_LITTLE_SYM
5979 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5980 #undef TARGET_LITTLE_NAME
5981 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5984 #define ELF_OSABI ELFOSABI_FREEBSD
5987 #define elf64_bed elf64_x86_64_fbsd_bed
5989 #include "elf64-target.h"
5991 /* Solaris 2 support. */
5993 #undef TARGET_LITTLE_SYM
5994 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5995 #undef TARGET_LITTLE_NAME
5996 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5998 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5999 objects won't be recognized. */
6003 #define elf64_bed elf64_x86_64_sol2_bed
6005 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6007 #undef elf_backend_static_tls_alignment
6008 #define elf_backend_static_tls_alignment 16
6010 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6012 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6014 #undef elf_backend_want_plt_sym
6015 #define elf_backend_want_plt_sym 1
6017 #include "elf64-target.h"
6019 /* Native Client support. */
6022 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6024 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6025 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6029 #undef TARGET_LITTLE_SYM
6030 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6031 #undef TARGET_LITTLE_NAME
6032 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6034 #define elf64_bed elf64_x86_64_nacl_bed
6036 #undef ELF_MAXPAGESIZE
6037 #undef ELF_MINPAGESIZE
6038 #undef ELF_COMMONPAGESIZE
6039 #define ELF_MAXPAGESIZE 0x10000
6040 #define ELF_MINPAGESIZE 0x10000
6041 #define ELF_COMMONPAGESIZE 0x10000
6043 /* Restore defaults. */
6045 #undef elf_backend_static_tls_alignment
6046 #undef elf_backend_want_plt_sym
6047 #define elf_backend_want_plt_sym 0
6049 /* NaCl uses substantially different PLT entries for the same effects. */
6051 #undef elf_backend_plt_alignment
6052 #define elf_backend_plt_alignment 5
6053 #define NACL_PLT_ENTRY_SIZE 64
6054 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6056 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6058 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6059 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6060 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6061 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6062 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6064 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6065 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6067 /* 32 bytes of nop to pad out to the standard size. */
6068 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6069 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6070 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6071 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6072 0x66, /* excess data32 prefix */
6076 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6078 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6079 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6080 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6081 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6083 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6084 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6085 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6087 /* Lazy GOT entries point here (32-byte aligned). */
6088 0x68, /* pushq immediate */
6089 0, 0, 0, 0, /* replaced with index into relocation table. */
6090 0xe9, /* jmp relative */
6091 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6093 /* 22 bytes of nop to pad out to the standard size. */
6094 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6095 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6096 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6099 /* .eh_frame covering the .plt section. */
6101 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6103 #if (PLT_CIE_LENGTH != 20 \
6104 || PLT_FDE_LENGTH != 36 \
6105 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6106 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6107 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6109 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6110 0, 0, 0, 0, /* CIE ID */
6111 1, /* CIE version */
6112 'z', 'R', 0, /* Augmentation string */
6113 1, /* Code alignment factor */
6114 0x78, /* Data alignment factor */
6115 16, /* Return address column */
6116 1, /* Augmentation size */
6117 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6118 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6119 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6120 DW_CFA_nop
, DW_CFA_nop
,
6122 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6123 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6124 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6125 0, 0, 0, 0, /* .plt size goes here */
6126 0, /* Augmentation size */
6127 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6128 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6129 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6130 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6131 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6132 13, /* Block length */
6133 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6134 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6135 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6136 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6137 DW_CFA_nop
, DW_CFA_nop
6140 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6142 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6143 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6144 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6145 2, /* plt0_got1_offset */
6146 9, /* plt0_got2_offset */
6147 13, /* plt0_got2_insn_end */
6148 3, /* plt_got_offset */
6149 33, /* plt_reloc_offset */
6150 38, /* plt_plt_offset */
6151 7, /* plt_got_insn_size */
6152 42, /* plt_plt_insn_end */
6153 32, /* plt_lazy_offset */
6154 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6155 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6158 #undef elf_backend_arch_data
6159 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6161 #undef elf_backend_object_p
6162 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6163 #undef elf_backend_modify_segment_map
6164 #define elf_backend_modify_segment_map nacl_modify_segment_map
6165 #undef elf_backend_modify_program_headers
6166 #define elf_backend_modify_program_headers nacl_modify_program_headers
6167 #undef elf_backend_final_write_processing
6168 #define elf_backend_final_write_processing nacl_final_write_processing
6170 #include "elf64-target.h"
6172 /* Native Client x32 support. */
6175 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6177 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6178 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6182 #undef TARGET_LITTLE_SYM
6183 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6184 #undef TARGET_LITTLE_NAME
6185 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6187 #define elf32_bed elf32_x86_64_nacl_bed
6189 #define bfd_elf32_bfd_link_hash_table_create \
6190 elf_x86_64_link_hash_table_create
6191 #define bfd_elf32_bfd_reloc_type_lookup \
6192 elf_x86_64_reloc_type_lookup
6193 #define bfd_elf32_bfd_reloc_name_lookup \
6194 elf_x86_64_reloc_name_lookup
6195 #define bfd_elf32_mkobject \
6197 #define bfd_elf32_get_synthetic_symtab \
6198 elf_x86_64_get_synthetic_symtab
6200 #undef elf_backend_object_p
6201 #define elf_backend_object_p \
6202 elf32_x86_64_nacl_elf_object_p
6204 #undef elf_backend_bfd_from_remote_memory
6205 #define elf_backend_bfd_from_remote_memory \
6206 _bfd_elf32_bfd_from_remote_memory
6208 #undef elf_backend_size_info
6209 #define elf_backend_size_info \
6210 _bfd_elf32_size_info
6212 #include "elf32-target.h"
6214 /* Restore defaults. */
6215 #undef elf_backend_object_p
6216 #define elf_backend_object_p elf64_x86_64_elf_object_p
6217 #undef elf_backend_bfd_from_remote_memory
6218 #undef elf_backend_size_info
6219 #undef elf_backend_modify_segment_map
6220 #undef elf_backend_modify_program_headers
6221 #undef elf_backend_final_write_processing
6223 /* Intel L1OM support. */
6226 elf64_l1om_elf_object_p (bfd
*abfd
)
6228 /* Set the right machine number for an L1OM elf64 file. */
6229 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6233 #undef TARGET_LITTLE_SYM
6234 #define TARGET_LITTLE_SYM l1om_elf64_vec
6235 #undef TARGET_LITTLE_NAME
6236 #define TARGET_LITTLE_NAME "elf64-l1om"
6238 #define ELF_ARCH bfd_arch_l1om
6240 #undef ELF_MACHINE_CODE
6241 #define ELF_MACHINE_CODE EM_L1OM
6246 #define elf64_bed elf64_l1om_bed
6248 #undef elf_backend_object_p
6249 #define elf_backend_object_p elf64_l1om_elf_object_p
6251 /* Restore defaults. */
6252 #undef ELF_MAXPAGESIZE
6253 #undef ELF_MINPAGESIZE
6254 #undef ELF_COMMONPAGESIZE
6255 #define ELF_MAXPAGESIZE 0x200000
6256 #define ELF_MINPAGESIZE 0x1000
6257 #define ELF_COMMONPAGESIZE 0x1000
6258 #undef elf_backend_plt_alignment
6259 #define elf_backend_plt_alignment 4
6260 #undef elf_backend_arch_data
6261 #define elf_backend_arch_data &elf_x86_64_arch_bed
6263 #include "elf64-target.h"
6265 /* FreeBSD L1OM support. */
6267 #undef TARGET_LITTLE_SYM
6268 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6269 #undef TARGET_LITTLE_NAME
6270 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6273 #define ELF_OSABI ELFOSABI_FREEBSD
6276 #define elf64_bed elf64_l1om_fbsd_bed
6278 #include "elf64-target.h"
6280 /* Intel K1OM support. */
6283 elf64_k1om_elf_object_p (bfd
*abfd
)
6285 /* Set the right machine number for an K1OM elf64 file. */
6286 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6290 #undef TARGET_LITTLE_SYM
6291 #define TARGET_LITTLE_SYM k1om_elf64_vec
6292 #undef TARGET_LITTLE_NAME
6293 #define TARGET_LITTLE_NAME "elf64-k1om"
6295 #define ELF_ARCH bfd_arch_k1om
6297 #undef ELF_MACHINE_CODE
6298 #define ELF_MACHINE_CODE EM_K1OM
6303 #define elf64_bed elf64_k1om_bed
6305 #undef elf_backend_object_p
6306 #define elf_backend_object_p elf64_k1om_elf_object_p
6308 #undef elf_backend_static_tls_alignment
6310 #undef elf_backend_want_plt_sym
6311 #define elf_backend_want_plt_sym 0
6313 #include "elf64-target.h"
6315 /* FreeBSD K1OM support. */
6317 #undef TARGET_LITTLE_SYM
6318 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6319 #undef TARGET_LITTLE_NAME
6320 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6323 #define ELF_OSABI ELFOSABI_FREEBSD
6326 #define elf64_bed elf64_k1om_fbsd_bed
6328 #include "elf64-target.h"
6330 /* 32bit x86-64 support. */
6332 #undef TARGET_LITTLE_SYM
6333 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6334 #undef TARGET_LITTLE_NAME
6335 #define TARGET_LITTLE_NAME "elf32-x86-64"
6339 #define ELF_ARCH bfd_arch_i386
6341 #undef ELF_MACHINE_CODE
6342 #define ELF_MACHINE_CODE EM_X86_64
6346 #undef elf_backend_object_p
6347 #define elf_backend_object_p \
6348 elf32_x86_64_elf_object_p
6350 #undef elf_backend_bfd_from_remote_memory
6351 #define elf_backend_bfd_from_remote_memory \
6352 _bfd_elf32_bfd_from_remote_memory
6354 #undef elf_backend_size_info
6355 #define elf_backend_size_info \
6356 _bfd_elf32_size_info
6358 #include "elf32-target.h"